3169 lines
240 KiB
HTML
3169 lines
240 KiB
HTML
<!doctype html>
|
||
<html lang="en">
|
||
<head>
|
||
<meta charset="utf-8">
|
||
<meta name="viewport" content="width=device-width">
|
||
<meta name="nodejs.org:node-version" content="v12.22.12">
|
||
<title>Buffer | Node.js v12.22.12 Documentation</title>
|
||
<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
|
||
<link rel="stylesheet" href="assets/style.css">
|
||
<link rel="stylesheet" href="assets/hljs.css">
|
||
<link rel="canonical" href="https://nodejs.org/api/buffer.html">
|
||
</head>
|
||
<body class="alt apidoc" id="api-section-buffer">
|
||
<div id="content" class="clearfix">
|
||
<div id="column2" class="interior">
|
||
<div id="intro" class="interior">
|
||
<a href="/" title="Go back to the home page">
|
||
Node.js
|
||
</a>
|
||
</div>
|
||
<ul>
|
||
<li><a href="documentation.html" class="nav-documentation">About this documentation</a></li>
|
||
<li><a href="synopsis.html" class="nav-synopsis">Usage and example</a></li>
|
||
</ul>
|
||
<hr class="line">
|
||
<ul>
|
||
<li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
|
||
<li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
|
||
<li><a href="buffer.html" class="nav-buffer active">Buffer</a></li>
|
||
<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
|
||
<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
|
||
<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
|
||
<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
|
||
<li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
|
||
<li><a href="cli.html" class="nav-cli">Command line options</a></li>
|
||
<li><a href="console.html" class="nav-console">Console</a></li>
|
||
<li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
|
||
<li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
|
||
<li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
|
||
<li><a href="dns.html" class="nav-dns">DNS</a></li>
|
||
<li><a href="domain.html" class="nav-domain">Domain</a></li>
|
||
<li><a href="errors.html" class="nav-errors">Errors</a></li>
|
||
<li><a href="events.html" class="nav-events">Events</a></li>
|
||
<li><a href="fs.html" class="nav-fs">File system</a></li>
|
||
<li><a href="globals.html" class="nav-globals">Globals</a></li>
|
||
<li><a href="http.html" class="nav-http">HTTP</a></li>
|
||
<li><a href="http2.html" class="nav-http2">HTTP/2</a></li>
|
||
<li><a href="https.html" class="nav-https">HTTPS</a></li>
|
||
<li><a href="inspector.html" class="nav-inspector">Inspector</a></li>
|
||
<li><a href="intl.html" class="nav-intl">Internationalization</a></li>
|
||
<li><a href="modules.html" class="nav-modules">Modules: CommonJS modules</a></li>
|
||
<li><a href="esm.html" class="nav-esm">Modules: ECMAScript modules</a></li>
|
||
<li><a href="module.html" class="nav-module">Modules: <code>module</code> API</a></li>
|
||
<li><a href="packages.html" class="nav-packages">Modules: Packages</a></li>
|
||
<li><a href="net.html" class="nav-net">Net</a></li>
|
||
<li><a href="os.html" class="nav-os">OS</a></li>
|
||
<li><a href="path.html" class="nav-path">Path</a></li>
|
||
<li><a href="perf_hooks.html" class="nav-perf_hooks">Performance hooks</a></li>
|
||
<li><a href="policy.html" class="nav-policy">Policies</a></li>
|
||
<li><a href="process.html" class="nav-process">Process</a></li>
|
||
<li><a href="punycode.html" class="nav-punycode">Punycode</a></li>
|
||
<li><a href="querystring.html" class="nav-querystring">Query strings</a></li>
|
||
<li><a href="readline.html" class="nav-readline">Readline</a></li>
|
||
<li><a href="repl.html" class="nav-repl">REPL</a></li>
|
||
<li><a href="report.html" class="nav-report">Report</a></li>
|
||
<li><a href="stream.html" class="nav-stream">Stream</a></li>
|
||
<li><a href="string_decoder.html" class="nav-string_decoder">String decoder</a></li>
|
||
<li><a href="timers.html" class="nav-timers">Timers</a></li>
|
||
<li><a href="tls.html" class="nav-tls">TLS/SSL</a></li>
|
||
<li><a href="tracing.html" class="nav-tracing">Trace events</a></li>
|
||
<li><a href="tty.html" class="nav-tty">TTY</a></li>
|
||
<li><a href="dgram.html" class="nav-dgram">UDP/datagram</a></li>
|
||
<li><a href="url.html" class="nav-url">URL</a></li>
|
||
<li><a href="util.html" class="nav-util">Utilities</a></li>
|
||
<li><a href="v8.html" class="nav-v8">V8</a></li>
|
||
<li><a href="vm.html" class="nav-vm">VM</a></li>
|
||
<li><a href="wasi.html" class="nav-wasi">WASI</a></li>
|
||
<li><a href="worker_threads.html" class="nav-worker_threads">Worker threads</a></li>
|
||
<li><a href="zlib.html" class="nav-zlib">Zlib</a></li>
|
||
</ul>
|
||
<hr class="line">
|
||
<ul>
|
||
<li><a href="https://github.com/nodejs/node" class="nav-https-github-com-nodejs-node">Code repository and issue tracker</a></li>
|
||
</ul>
|
||
</div>
|
||
|
||
<div id="column1" data-id="buffer" class="interior">
|
||
<header>
|
||
<h1>Node.js v12.22.12 Documentation</h1>
|
||
<div id="gtoc">
|
||
<ul>
|
||
<li>
|
||
<a href="index.html">Index</a>
|
||
</li>
|
||
<li>
|
||
<a href="all.html">View on single page</a>
|
||
</li>
|
||
<li>
|
||
<a href="buffer.json">View as JSON</a>
|
||
</li>
|
||
|
||
<li class="version-picker">
|
||
<a href="#">View another version <span>▼</span></a>
|
||
<ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/buffer.html">17.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v16.x/api/buffer.html">16.x <b>LTS</b></a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v15.x/api/buffer.html">15.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v14.x/api/buffer.html">14.x <b>LTS</b></a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v13.x/api/buffer.html">13.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v12.x/api/buffer.html">12.x <b>LTS</b></a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v11.x/api/buffer.html">11.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v10.x/api/buffer.html">10.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v9.x/api/buffer.html">9.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v8.x/api/buffer.html">8.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v7.x/api/buffer.html">7.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v6.x/api/buffer.html">6.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v5.x/api/buffer.html">5.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v4.x/api/buffer.html">4.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v0.12.x/api/buffer.html">0.12.x</a></li>
|
||
<li><a href="https://nodejs.org/docs/latest-v0.10.x/api/buffer.html">0.10.x</a></li></ol>
|
||
</li>
|
||
|
||
<li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/buffer.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
|
||
</ul>
|
||
</div>
|
||
<hr>
|
||
</header>
|
||
|
||
<div id="toc">
|
||
<h2>Table of Contents</h2>
|
||
<ul>
|
||
<li><span class="stability_2"><a href="#buffer_buffer">Buffer</a></span>
|
||
<ul>
|
||
<li><a href="#buffer_buffers_and_character_encodings">Buffers and character encodings</a></li>
|
||
<li><a href="#buffer_buffers_and_typedarrays">Buffers and TypedArrays</a></li>
|
||
<li><a href="#buffer_buffers_and_iteration">Buffers and iteration</a></li>
|
||
<li><a href="#buffer_class_buffer">Class: <code>Buffer</code></a>
|
||
<ul>
|
||
<li><a href="#buffer_static_method_buffer_alloc_size_fill_encoding">Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_allocunsafe_size">Static method: <code>Buffer.allocUnsafe(size)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_allocunsafeslow_size">Static method: <code>Buffer.allocUnsafeSlow(size)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_bytelength_string_encoding">Static method: <code>Buffer.byteLength(string[, encoding])</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_compare_buf1_buf2">Static method: <code>Buffer.compare(buf1, buf2)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_concat_list_totallength">Static method: <code>Buffer.concat(list[, totalLength])</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_array">Static method: <code>Buffer.from(array)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length">Static method: <code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_buffer">Static method: <code>Buffer.from(buffer)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_object_offsetorencoding_length">Static method: <code>Buffer.from(object[, offsetOrEncoding[, length]])</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_string_encoding">Static method: <code>Buffer.from(string[, encoding])</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_isbuffer_obj">Static method: <code>Buffer.isBuffer(obj)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_isencoding_encoding">Static method: <code>Buffer.isEncoding(encoding)</code></a></li>
|
||
<li><a href="#buffer_class_property_buffer_poolsize">Class property: <code>Buffer.poolSize</code></a></li>
|
||
<li><a href="#buffer_buf_index"><code>buf[index]</code></a></li>
|
||
<li><a href="#buffer_buf_buffer"><code>buf.buffer</code></a></li>
|
||
<li><a href="#buffer_buf_byteoffset"><code>buf.byteOffset</code></a></li>
|
||
<li><a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])</code></a></li>
|
||
<li><a href="#buffer_buf_copy_target_targetstart_sourcestart_sourceend"><code>buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])</code></a></li>
|
||
<li><a href="#buffer_buf_entries"><code>buf.entries()</code></a></li>
|
||
<li><a href="#buffer_buf_equals_otherbuffer"><code>buf.equals(otherBuffer)</code></a></li>
|
||
<li><a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(value[, offset[, end]][, encoding])</code></a></li>
|
||
<li><a href="#buffer_buf_includes_value_byteoffset_encoding"><code>buf.includes(value[, byteOffset][, encoding])</code></a></li>
|
||
<li><a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf(value[, byteOffset][, encoding])</code></a></li>
|
||
<li><a href="#buffer_buf_keys"><code>buf.keys()</code></a></li>
|
||
<li><a href="#buffer_buf_lastindexof_value_byteoffset_encoding"><code>buf.lastIndexOf(value[, byteOffset][, encoding])</code></a></li>
|
||
<li><a href="#buffer_buf_length"><code>buf.length</code></a></li>
|
||
<li><span class="stability_0"><a href="#buffer_buf_parent"><code>buf.parent</code></a></span></li>
|
||
<li><a href="#buffer_buf_readbigint64be_offset"><code>buf.readBigInt64BE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readbigint64le_offset"><code>buf.readBigInt64LE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readbiguint64be_offset"><code>buf.readBigUInt64BE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readbiguint64le_offset"><code>buf.readBigUInt64LE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readdoublebe_offset"><code>buf.readDoubleBE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readdoublele_offset"><code>buf.readDoubleLE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readfloatbe_offset"><code>buf.readFloatBE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readfloatle_offset"><code>buf.readFloatLE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readint8_offset"><code>buf.readInt8([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readint16be_offset"><code>buf.readInt16BE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readint16le_offset"><code>buf.readInt16LE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readint32be_offset"><code>buf.readInt32BE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readint32le_offset"><code>buf.readInt32LE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readintbe_offset_bytelength"><code>buf.readIntBE(offset, byteLength)</code></a></li>
|
||
<li><a href="#buffer_buf_readintle_offset_bytelength"><code>buf.readIntLE(offset, byteLength)</code></a></li>
|
||
<li><a href="#buffer_buf_readuint8_offset"><code>buf.readUInt8([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readuint16be_offset"><code>buf.readUInt16BE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readuint16le_offset"><code>buf.readUInt16LE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readuint32be_offset"><code>buf.readUInt32BE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readuint32le_offset"><code>buf.readUInt32LE([offset])</code></a></li>
|
||
<li><a href="#buffer_buf_readuintbe_offset_bytelength"><code>buf.readUIntBE(offset, byteLength)</code></a></li>
|
||
<li><a href="#buffer_buf_readuintle_offset_bytelength"><code>buf.readUIntLE(offset, byteLength)</code></a></li>
|
||
<li><a href="#buffer_buf_subarray_start_end"><code>buf.subarray([start[, end]])</code></a></li>
|
||
<li><a href="#buffer_buf_slice_start_end"><code>buf.slice([start[, end]])</code></a></li>
|
||
<li><a href="#buffer_buf_swap16"><code>buf.swap16()</code></a></li>
|
||
<li><a href="#buffer_buf_swap32"><code>buf.swap32()</code></a></li>
|
||
<li><a href="#buffer_buf_swap64"><code>buf.swap64()</code></a></li>
|
||
<li><a href="#buffer_buf_tojson"><code>buf.toJSON()</code></a></li>
|
||
<li><a href="#buffer_buf_tostring_encoding_start_end"><code>buf.toString([encoding[, start[, end]]])</code></a></li>
|
||
<li><a href="#buffer_buf_values"><code>buf.values()</code></a></li>
|
||
<li><a href="#buffer_buf_write_string_offset_length_encoding"><code>buf.write(string[, offset[, length]][, encoding])</code></a></li>
|
||
<li><a href="#buffer_buf_writebigint64be_value_offset"><code>buf.writeBigInt64BE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writebigint64le_value_offset"><code>buf.writeBigInt64LE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writebiguint64be_value_offset"><code>buf.writeBigUInt64BE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writebiguint64le_value_offset"><code>buf.writeBigUInt64LE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writedoublebe_value_offset"><code>buf.writeDoubleBE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writedoublele_value_offset"><code>buf.writeDoubleLE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writefloatbe_value_offset"><code>buf.writeFloatBE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writefloatle_value_offset"><code>buf.writeFloatLE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeint8_value_offset"><code>buf.writeInt8(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeint16be_value_offset"><code>buf.writeInt16BE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeint16le_value_offset"><code>buf.writeInt16LE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeint32be_value_offset"><code>buf.writeInt32BE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeint32le_value_offset"><code>buf.writeInt32LE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeintbe_value_offset_bytelength"><code>buf.writeIntBE(value, offset, byteLength)</code></a></li>
|
||
<li><a href="#buffer_buf_writeintle_value_offset_bytelength"><code>buf.writeIntLE(value, offset, byteLength)</code></a></li>
|
||
<li><a href="#buffer_buf_writeuint8_value_offset"><code>buf.writeUInt8(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeuint16be_value_offset"><code>buf.writeUInt16BE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeuint16le_value_offset"><code>buf.writeUInt16LE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeuint32be_value_offset"><code>buf.writeUInt32BE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeuint32le_value_offset"><code>buf.writeUInt32LE(value[, offset])</code></a></li>
|
||
<li><a href="#buffer_buf_writeuintbe_value_offset_bytelength"><code>buf.writeUIntBE(value, offset, byteLength)</code></a></li>
|
||
<li><a href="#buffer_buf_writeuintle_value_offset_bytelength"><code>buf.writeUIntLE(value, offset, byteLength)</code></a></li>
|
||
<li><span class="stability_0"><a href="#buffer_new_buffer_array"><code>new Buffer(array)</code></a></span></li>
|
||
<li><span class="stability_0"><a href="#buffer_new_buffer_arraybuffer_byteoffset_length"><code>new Buffer(arrayBuffer[, byteOffset[, length]])</code></a></span></li>
|
||
<li><span class="stability_0"><a href="#buffer_new_buffer_buffer"><code>new Buffer(buffer)</code></a></span></li>
|
||
<li><span class="stability_0"><a href="#buffer_new_buffer_size"><code>new Buffer(size)</code></a></span></li>
|
||
<li><span class="stability_0"><a href="#buffer_new_buffer_string_encoding"><code>new Buffer(string[, encoding])</code></a></span></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#buffer_buffer_module_apis"><code>buffer</code> module APIs</a>
|
||
<ul>
|
||
<li><a href="#buffer_buffer_inspect_max_bytes"><code>buffer.INSPECT_MAX_BYTES</code></a></li>
|
||
<li><a href="#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a></li>
|
||
<li><a href="#buffer_buffer_transcode_source_fromenc_toenc"><code>buffer.transcode(source, fromEnc, toEnc)</code></a></li>
|
||
<li><span class="stability_0"><a href="#buffer_class_slowbuffer">Class: <code>SlowBuffer</code></a></span>
|
||
<ul>
|
||
<li><span class="stability_0"><a href="#buffer_new_slowbuffer_size"><code>new SlowBuffer(size)</code></a></span></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#buffer_buffer_constants">Buffer constants</a>
|
||
<ul>
|
||
<li><a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a></li>
|
||
<li><a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.MAX_STRING_LENGTH</code></a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe"><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code></a>
|
||
<ul>
|
||
<li><a href="#buffer_the_zero_fill_buffers_command_line_option">The <code>--zero-fill-buffers</code> command line option</a></li>
|
||
<li><a href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
|
||
<div id="apicontent">
|
||
<h1>Buffer<span><a class="mark" href="#buffer_buffer" id="buffer_buffer">#</a></span></h1>
|
||
|
||
<p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
|
||
<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.12/lib/buffer.js">lib/buffer.js</a></p>
|
||
<p><code>Buffer</code> objects are used to represent a fixed-length sequence of bytes. Many
|
||
Node.js APIs support <code>Buffer</code>s.</p>
|
||
<p>The <code>Buffer</code> class is a subclass of JavaScript's <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> class and
|
||
extends it with methods that cover additional use cases. Node.js APIs accept
|
||
plain <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a>s wherever <code>Buffer</code>s are supported as well.</p>
|
||
<p>The <code>Buffer</code> class is within the global scope, making it unlikely that one
|
||
would need to ever use <code>require('buffer').Buffer</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Creates a zero-filled Buffer of length 10.</span>
|
||
<span class="hljs-keyword">const</span> buf1 = Buffer.alloc(<span class="hljs-number">10</span>);
|
||
|
||
<span class="hljs-comment">// Creates a Buffer of length 10,</span>
|
||
<span class="hljs-comment">// filled with bytes which all have the value `1`.</span>
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.alloc(<span class="hljs-number">10</span>, <span class="hljs-number">1</span>);
|
||
|
||
<span class="hljs-comment">// Creates an uninitialized buffer of length 10.</span>
|
||
<span class="hljs-comment">// This is faster than calling Buffer.alloc() but the returned</span>
|
||
<span class="hljs-comment">// Buffer instance might contain old data that needs to be</span>
|
||
<span class="hljs-comment">// overwritten using fill(), write(), or other functions that fill the Buffer's</span>
|
||
<span class="hljs-comment">// contents.</span>
|
||
<span class="hljs-keyword">const</span> buf3 = Buffer.allocUnsafe(<span class="hljs-number">10</span>);
|
||
|
||
<span class="hljs-comment">// Creates a Buffer containing the bytes [1, 2, 3].</span>
|
||
<span class="hljs-keyword">const</span> buf4 = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
|
||
|
||
<span class="hljs-comment">// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries</span>
|
||
<span class="hljs-comment">// are all truncated using `(value & 255)` to fit into the range 0–255.</span>
|
||
<span class="hljs-keyword">const</span> buf5 = Buffer.from([<span class="hljs-number">257</span>, <span class="hljs-number">257.5</span>, <span class="hljs-number">-255</span>, <span class="hljs-string">'1'</span>]);
|
||
|
||
<span class="hljs-comment">// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':</span>
|
||
<span class="hljs-comment">// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)</span>
|
||
<span class="hljs-comment">// [116, 195, 169, 115, 116] (in decimal notation)</span>
|
||
<span class="hljs-keyword">const</span> buf6 = Buffer.from(<span class="hljs-string">'tést'</span>);
|
||
|
||
<span class="hljs-comment">// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].</span>
|
||
<span class="hljs-keyword">const</span> buf7 = Buffer.from(<span class="hljs-string">'tést'</span>, <span class="hljs-string">'latin1'</span>);</code></pre>
|
||
<h2>Buffers and character encodings<span><a class="mark" href="#buffer_buffers_and_character_encodings" id="buffer_buffers_and_character_encodings">#</a></span></h2>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v6.4.0</td>
|
||
<td><p>Introduced <code>latin1</code> as an alias for <code>binary</code>.</p></td></tr>
|
||
<tr><td>v5.0.0</td>
|
||
<td><p>Removed the deprecated <code>raw</code> and <code>raws</code> encodings.</p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<p>When converting between <code>Buffer</code>s and strings, a character encoding may be
|
||
specified. If no character encoding is specified, UTF-8 will be used as the
|
||
default.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'hello world'</span>, <span class="hljs-string">'utf8'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
|
||
<span class="hljs-comment">// Prints: 68656c6c6f20776f726c64</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'base64'</span>));
|
||
<span class="hljs-comment">// Prints: aGVsbG8gd29ybGQ=</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(Buffer.from(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf8'</span>));
|
||
<span class="hljs-comment">// Prints: <Buffer 66 68 71 77 68 67 61 64 73></span>
|
||
<span class="hljs-built_in">console</span>.log(Buffer.from(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf16le'</span>));
|
||
<span class="hljs-comment">// Prints: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00></span></code></pre>
|
||
<p>The character encodings currently supported by Node.js are the following:</p>
|
||
<ul>
|
||
<li>
|
||
<p><code>'utf8'</code>: Multi-byte encoded Unicode characters. Many web pages and other
|
||
document formats use <a href="https://en.wikipedia.org/wiki/UTF-8">UTF-8</a>. This is the default character encoding.
|
||
When decoding a <code>Buffer</code> into a string that does not exclusively contain
|
||
valid UTF-8 data, the Unicode replacement character <code>U+FFFD</code> <20> will be used
|
||
to represent those errors.</p>
|
||
</li>
|
||
<li>
|
||
<p><code>'utf16le'</code>: Multi-byte encoded Unicode characters. Unlike <code>'utf8'</code>, each
|
||
character in the string will be encoded using either 2 or 4 bytes.
|
||
Node.js only supports the <a href="https://en.wikipedia.org/wiki/Endianness">little-endian</a> variant of <a href="https://en.wikipedia.org/wiki/UTF-16">UTF-16</a>.</p>
|
||
</li>
|
||
<li>
|
||
<p><code>'latin1'</code>: Latin-1 stands for <a href="https://en.wikipedia.org/wiki/ISO-8859-1">ISO-8859-1</a>. This character encoding only
|
||
supports the Unicode characters from <code>U+0000</code> to <code>U+00FF</code>. Each character is
|
||
encoded using a single byte. Characters that do not fit into that range are
|
||
truncated and will be mapped to characters in that range.</p>
|
||
</li>
|
||
</ul>
|
||
<p>Converting a <code>Buffer</code> into a string using one of the above is referred to as
|
||
decoding, and converting a string into a <code>Buffer</code> is referred to as encoding.</p>
|
||
<p>Node.js also supports the following two binary-to-text encodings. For
|
||
binary-to-text encodings, the naming convention is reversed: Converting a
|
||
<code>Buffer</code> into a string is typically referred to as encoding, and converting a
|
||
string into a <code>Buffer</code> as decoding.</p>
|
||
<ul>
|
||
<li>
|
||
<p><code>'base64'</code>: <a href="https://en.wikipedia.org/wiki/Base64">Base64</a> encoding. When creating a <code>Buffer</code> from a string,
|
||
this encoding will also correctly accept "URL and Filename Safe Alphabet" as
|
||
specified in <a href="https://tools.ietf.org/html/rfc4648#section-5">RFC 4648, Section 5</a>. Whitespace characters such as spaces,
|
||
tabs, and new lines contained within the base64-encoded string are ignored.</p>
|
||
</li>
|
||
<li>
|
||
<p><code>'hex'</code>: Encode each byte as two hexadecimal characters. Data truncation
|
||
may occur when decoding strings that do exclusively contain valid hexadecimal
|
||
characters. See below for an example.</p>
|
||
</li>
|
||
</ul>
|
||
<p>The following legacy character encodings are also supported:</p>
|
||
<ul>
|
||
<li>
|
||
<p><code>'ascii'</code>: For 7-bit <a href="https://en.wikipedia.org/wiki/ASCII">ASCII</a> data only. When encoding a string into a
|
||
<code>Buffer</code>, this is equivalent to using <code>'latin1'</code>. When decoding a <code>Buffer</code>
|
||
into a string, using this encoding will additionally unset the highest bit of
|
||
each byte before decoding as <code>'latin1'</code>.
|
||
Generally, there should be no reason to use this encoding, as <code>'utf8'</code>
|
||
(or, if the data is known to always be ASCII-only, <code>'latin1'</code>) will be a
|
||
better choice when encoding or decoding ASCII-only text. It is only provided
|
||
for legacy compatibility.</p>
|
||
</li>
|
||
<li>
|
||
<p><code>'binary'</code>: Alias for <code>'latin1'</code>. See <a href="https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary">binary strings</a> for more background
|
||
on this topic. The name of this encoding can be very misleading, as all of the
|
||
encodings listed here convert between strings and binary data. For converting
|
||
between strings and <code>Buffer</code>s, typically <code>'utf-8'</code> is the right choice.</p>
|
||
</li>
|
||
<li>
|
||
<p><code>'ucs2'</code>: Alias of <code>'utf16le'</code>. UCS-2 used to refer to a variant of UTF-16
|
||
that did not support characters that had code points larger than U+FFFF.
|
||
In Node.js, these code points are always supported.</p>
|
||
</li>
|
||
</ul>
|
||
<pre><code class="language-js">Buffer.from(<span class="hljs-string">'1ag'</span>, <span class="hljs-string">'hex'</span>);
|
||
<span class="hljs-comment">// Prints <Buffer 1a>, data truncated when first non-hexadecimal value</span>
|
||
<span class="hljs-comment">// ('g') encountered.</span>
|
||
|
||
Buffer.from(<span class="hljs-string">'1a7g'</span>, <span class="hljs-string">'hex'</span>);
|
||
<span class="hljs-comment">// Prints <Buffer 1a>, data truncated when data ends in single digit ('7').</span>
|
||
|
||
Buffer.from(<span class="hljs-string">'1634'</span>, <span class="hljs-string">'hex'</span>);
|
||
<span class="hljs-comment">// Prints <Buffer 16 34>, all data represented.</span></code></pre>
|
||
<p>Modern Web browsers follow the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a> which aliases
|
||
both <code>'latin1'</code> and <code>'ISO-8859-1'</code> to <code>'win-1252'</code>. This means that while doing
|
||
something like <code>http.get()</code>, if the returned charset is one of those listed in
|
||
the WHATWG specification it is possible that the server actually returned
|
||
<code>'win-1252'</code>-encoded data, and using <code>'latin1'</code> encoding may incorrectly decode
|
||
the characters.</p>
|
||
<h2>Buffers and TypedArrays<span><a class="mark" href="#buffer_buffers_and_typedarrays" id="buffer_buffers_and_typedarrays">#</a></span></h2>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v3.0.0</td>
|
||
<td><p>The <code>Buffer</code>s class now inherits from <code>Uint8Array</code>.</p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<p><code>Buffer</code> instances are also JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>
|
||
instances. All <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> methods are available on <code>Buffer</code>s. There are,
|
||
however, subtle incompatibilities between the <code>Buffer</code> API and the
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> API.</p>
|
||
<p>In particular:</p>
|
||
<ul>
|
||
<li>While <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice"><code>TypedArray#slice()</code></a> creates a copy of part of the <code>TypedArray</code>,
|
||
<a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> creates a view over the existing <code>Buffer</code>
|
||
without copying. This behavior can be surprising, and only exists for legacy
|
||
compatibility. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray#subarray()</code></a> can be used to achieve the behavior
|
||
of <a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> on both <code>Buffer</code>s and other
|
||
<code>TypedArray</code>s.</li>
|
||
<li><a href="#buffer_buf_tostring_encoding_start_end"><code>buf.toString()</code></a> is incompatible with its <code>TypedArray</code> equivalent.</li>
|
||
<li>A number of methods, e.g. <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf()</code></a>, support additional arguments.</li>
|
||
</ul>
|
||
<p>There are two ways to create new <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instances from a <code>Buffer</code>:</p>
|
||
<ul>
|
||
<li>Passing a <code>Buffer</code> to a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> constructor will copy the <code>Buffer</code>s
|
||
contents, interpreted as an array of integers, and not as a byte sequence
|
||
of the target type.</li>
|
||
</ul>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
|
||
<span class="hljs-keyword">const</span> uint32array = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>(buf);
|
||
|
||
<span class="hljs-built_in">console</span>.log(uint32array);
|
||
|
||
<span class="hljs-comment">// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]</span></code></pre>
|
||
<ul>
|
||
<li>Passing the <code>Buffer</code>s underlying <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> will create a
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> that shares its memory with the <code>Buffer</code>.</li>
|
||
</ul>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'hello'</span>, <span class="hljs-string">'utf16le'</span>);
|
||
<span class="hljs-keyword">const</span> uint16arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(
|
||
buf.buffer,
|
||
buf.byteOffset,
|
||
buf.length / <span class="hljs-built_in">Uint16Array</span>.BYTES_PER_ELEMENT);
|
||
|
||
<span class="hljs-built_in">console</span>.log(uint16array);
|
||
|
||
<span class="hljs-comment">// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]</span></code></pre>
|
||
<p>It is possible to create a new <code>Buffer</code> that shares the same allocated
|
||
memory as a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance by using the <code>TypedArray</code> object’s
|
||
<code>.buffer</code> property in the same way. <a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from()</code></a>
|
||
behaves like <code>new Uint8Array()</code> in this context.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">2</span>);
|
||
|
||
arr[<span class="hljs-number">0</span>] = <span class="hljs-number">5000</span>;
|
||
arr[<span class="hljs-number">1</span>] = <span class="hljs-number">4000</span>;
|
||
|
||
<span class="hljs-comment">// Copies the contents of `arr`.</span>
|
||
<span class="hljs-keyword">const</span> buf1 = Buffer.from(arr);
|
||
|
||
<span class="hljs-comment">// Shares memory with `arr`.</span>
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from(arr.buffer);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 88 a0></span>
|
||
<span class="hljs-built_in">console</span>.log(buf2);
|
||
<span class="hljs-comment">// Prints: <Buffer 88 13 a0 0f></span>
|
||
|
||
arr[<span class="hljs-number">1</span>] = <span class="hljs-number">6000</span>;
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 88 a0></span>
|
||
<span class="hljs-built_in">console</span>.log(buf2);
|
||
<span class="hljs-comment">// Prints: <Buffer 88 13 70 17></span></code></pre>
|
||
<p>When creating a <code>Buffer</code> using a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>'s <code>.buffer</code>, it is
|
||
possible to use only a portion of the underlying <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> by passing in
|
||
<code>byteOffset</code> and <code>length</code> parameters.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">20</span>);
|
||
<span class="hljs-keyword">const</span> buf = Buffer.from(arr.buffer, <span class="hljs-number">0</span>, <span class="hljs-number">16</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.length);
|
||
<span class="hljs-comment">// Prints: 16</span></code></pre>
|
||
<p>The <code>Buffer.from()</code> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from"><code>TypedArray.from()</code></a> have different signatures and
|
||
implementations. Specifically, the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> variants accept a second
|
||
argument that is a mapping function that is invoked on every element of the
|
||
typed array:</p>
|
||
<ul>
|
||
<li><code>TypedArray.from(source[, mapFn[, thisArg]])</code></li>
|
||
</ul>
|
||
<p>The <code>Buffer.from()</code> method, however, does not support the use of a mapping
|
||
function:</p>
|
||
<ul>
|
||
<li><a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_buffer"><code>Buffer.from(buffer)</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>
|
||
<li><a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a></li>
|
||
</ul>
|
||
<h2>Buffers and iteration<span><a class="mark" href="#buffer_buffers_and_iteration" id="buffer_buffers_and_iteration">#</a></span></h2>
|
||
<p><code>Buffer</code> instances can be iterated over using <code>for..of</code> syntax:</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> b <span class="hljs-keyword">of</span> buf) {
|
||
<span class="hljs-built_in">console</span>.log(b);
|
||
}
|
||
<span class="hljs-comment">// Prints:</span>
|
||
<span class="hljs-comment">// 1</span>
|
||
<span class="hljs-comment">// 2</span>
|
||
<span class="hljs-comment">// 3</span></code></pre>
|
||
<p>Additionally, the <a href="#buffer_buf_values"><code>buf.values()</code></a>, <a href="#buffer_buf_keys"><code>buf.keys()</code></a>, and
|
||
<a href="#buffer_buf_entries"><code>buf.entries()</code></a> methods can be used to create iterators.</p>
|
||
<h2>Class: <code>Buffer</code><span><a class="mark" href="#buffer_class_buffer" id="buffer_class_buffer">#</a></span></h2>
|
||
<p>The <code>Buffer</code> class is a global type for dealing with binary data directly.
|
||
It can be constructed in a variety of ways.</p>
|
||
<h3>Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code><span><a class="mark" href="#buffer_static_method_buffer_alloc_size_fill_encoding" id="buffer_static_method_buffer_alloc_size_fill_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Attempting to fill a non-zero length buffer with a zero length buffer triggers a thrown exception.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Specifying an invalid string for <code>fill</code> triggers a thrown exception.</p></td></tr>
|
||
<tr><td>v8.9.3</td>
|
||
<td><p>Specifying an invalid string for <code>fill</code> now results in a zero-filled buffer.</p></td></tr>
|
||
<tr><td>v5.10.0</td>
|
||
<td><p><span>Added in: v5.10.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The desired length of the new <code>Buffer</code>.</li>
|
||
<li><code>fill</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> | <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> A value to pre-fill the new <code>Buffer</code>
|
||
with. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> If <code>fill</code> is a string, this is its encoding.
|
||
<strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
</ul>
|
||
<p>Allocates a new <code>Buffer</code> of <code>size</code> bytes. If <code>fill</code> is <code>undefined</code>, the
|
||
<code>Buffer</code> will be zero-filled.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">5</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 00 00 00 00 00></span></code></pre>
|
||
<p>If <code>size</code> is larger than
|
||
<a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a> or smaller than 0, <a href="errors.html#ERR_INVALID_OPT_VALUE"><code>ERR_INVALID_OPT_VALUE</code></a>
|
||
is thrown.</p>
|
||
<p>If <code>fill</code> is specified, the allocated <code>Buffer</code> will be initialized by calling
|
||
<a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(fill)</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">5</span>, <span class="hljs-string">'a'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 61 61 61 61 61></span></code></pre>
|
||
<p>If both <code>fill</code> and <code>encoding</code> are specified, the allocated <code>Buffer</code> will be
|
||
initialized by calling <a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(fill, encoding)</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">11</span>, <span class="hljs-string">'aGVsbG8gd29ybGQ='</span>, <span class="hljs-string">'base64'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64></span></code></pre>
|
||
<p>Calling <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> can be measurably slower than the alternative
|
||
<a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> but ensures that the newly created <code>Buffer</code> instance
|
||
contents will never contain sensitive data from previous allocations, including
|
||
data that might not have been allocated for <code>Buffer</code>s.</p>
|
||
<p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
|
||
<h3>Static method: <code>Buffer.allocUnsafe(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafe_size" id="buffer_static_method_buffer_allocunsafe_size">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>Passing a negative <code>size</code> will now throw an error.</p></td></tr>
|
||
<tr><td>v5.10.0</td>
|
||
<td><p><span>Added in: v5.10.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The desired length of the new <code>Buffer</code>.</li>
|
||
</ul>
|
||
<p>Allocates a new <code>Buffer</code> of <code>size</code> bytes. If <code>size</code> is larger than
|
||
<a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a> or smaller than 0, <a href="errors.html#ERR_INVALID_OPT_VALUE"><code>ERR_INVALID_OPT_VALUE</code></a>
|
||
is thrown.</p>
|
||
<p>The underlying memory for <code>Buffer</code> instances created in this way is <em>not
|
||
initialized</em>. The contents of the newly created <code>Buffer</code> are unknown and
|
||
<em>may contain sensitive data</em>. Use <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> instead to initialize
|
||
<code>Buffer</code> instances with zeroes.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">10</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32></span>
|
||
|
||
buf.fill(<span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 00 00 00 00 00 00 00 00 00 00></span></code></pre>
|
||
<p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
|
||
<p>The <code>Buffer</code> module pre-allocates an internal <code>Buffer</code> instance of
|
||
size <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a> that is used as a pool for the fast allocation of new
|
||
<code>Buffer</code> instances created using <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>,
|
||
<a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a>, <a href="#buffer_static_method_buffer_concat_list_totallength"><code>Buffer.concat()</code></a>, and the deprecated
|
||
<code>new Buffer(size)</code> constructor only when <code>size</code> is less than or equal
|
||
to <code>Buffer.poolSize >> 1</code> (floor of <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a> divided by two).</p>
|
||
<p>Use of this pre-allocated internal memory pool is a key difference between
|
||
calling <code>Buffer.alloc(size, fill)</code> vs. <code>Buffer.allocUnsafe(size).fill(fill)</code>.
|
||
Specifically, <code>Buffer.alloc(size, fill)</code> will <em>never</em> use the internal <code>Buffer</code>
|
||
pool, while <code>Buffer.allocUnsafe(size).fill(fill)</code> <em>will</em> use the internal
|
||
<code>Buffer</code> pool if <code>size</code> is less than or equal to half <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a>. The
|
||
difference is subtle but can be important when an application requires the
|
||
additional performance that <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> provides.</p>
|
||
<h3>Static method: <code>Buffer.allocUnsafeSlow(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafeslow_size" id="buffer_static_method_buffer_allocunsafeslow_size">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.12.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The desired length of the new <code>Buffer</code>.</li>
|
||
</ul>
|
||
<p>Allocates a new <code>Buffer</code> of <code>size</code> bytes. If <code>size</code> is larger than
|
||
<a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a> or smaller than 0, <a href="errors.html#ERR_INVALID_OPT_VALUE"><code>ERR_INVALID_OPT_VALUE</code></a>
|
||
is thrown. A zero-length <code>Buffer</code> is created if <code>size</code> is 0.</p>
|
||
<p>The underlying memory for <code>Buffer</code> instances created in this way is <em>not
|
||
initialized</em>. The contents of the newly created <code>Buffer</code> are unknown and
|
||
<em>may contain sensitive data</em>. Use <a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(0)</code></a> to initialize
|
||
such <code>Buffer</code> instances with zeroes.</p>
|
||
<p>When using <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> to allocate new <code>Buffer</code> instances,
|
||
allocations under 4KB are sliced from a single pre-allocated <code>Buffer</code>. This
|
||
allows applications to avoid the garbage collection overhead of creating many
|
||
individually allocated <code>Buffer</code> instances. This approach improves both
|
||
performance and memory usage by eliminating the need to track and clean up as
|
||
many individual <code>ArrayBuffer</code> objects.</p>
|
||
<p>However, in the case where a developer may need to retain a small chunk of
|
||
memory from a pool for an indeterminate amount of time, it may be appropriate
|
||
to create an un-pooled <code>Buffer</code> instance using <code>Buffer.allocUnsafeSlow()</code> and
|
||
then copying out the relevant bits.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Need to keep around a few small chunks of memory.</span>
|
||
<span class="hljs-keyword">const</span> store = [];
|
||
|
||
socket.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
|
||
<span class="hljs-keyword">let</span> data;
|
||
<span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (data = readable.read())) {
|
||
<span class="hljs-comment">// Allocate for retained data.</span>
|
||
<span class="hljs-keyword">const</span> sb = Buffer.allocUnsafeSlow(<span class="hljs-number">10</span>);
|
||
|
||
<span class="hljs-comment">// Copy the data into the new allocation.</span>
|
||
data.copy(sb, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">10</span>);
|
||
|
||
store.push(sb);
|
||
}
|
||
});</code></pre>
|
||
<p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
|
||
<h3>Static method: <code>Buffer.byteLength(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_bytelength_string_encoding" id="buffer_static_method_buffer_bytelength_string_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>Passing invalid input will now throw an error.</p></td></tr>
|
||
<tr><td>v5.10.0</td>
|
||
<td><p>The <code>string</code> parameter can now be any <code>TypedArray</code>, <code>DataView</code> or <code>ArrayBuffer</code>.</p></td></tr>
|
||
<tr><td>v0.1.90</td>
|
||
<td><p><span>Added in: v0.1.90</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> | <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type"><TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type"><DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type"><ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer" class="type"><SharedArrayBuffer></a> A
|
||
value to calculate the length of.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> If <code>string</code> is a string, this is its encoding.
|
||
<strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The number of bytes contained within <code>string</code>.</li>
|
||
</ul>
|
||
<p>Returns the byte length of a string when encoded using <code>encoding</code>.
|
||
This is not the same as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length"><code>String.prototype.length</code></a>, which does not account
|
||
for the encoding that is used to convert the string into bytes.</p>
|
||
<p>For <code>'base64'</code> and <code>'hex'</code>, this function assumes valid input. For strings that
|
||
contain non-base64/hex-encoded data (e.g. whitespace), the return value might be
|
||
greater than the length of a <code>Buffer</code> created from the string.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> str = <span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>;
|
||
|
||
<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${str}</span>: <span class="hljs-subst">${str.length}</span> characters, `</span> +
|
||
<span class="hljs-string">`<span class="hljs-subst">${Buffer.byteLength(str, <span class="hljs-string">'utf8'</span>)}</span> bytes`</span>);
|
||
<span class="hljs-comment">// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes</span></code></pre>
|
||
<p>When <code>string</code> is a <code>Buffer</code>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>/
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a>, the byte length as reported by <code>.byteLength</code>
|
||
is returned.</p>
|
||
<h3>Static method: <code>Buffer.compare(buf1, buf2)</code><span><a class="mark" href="#buffer_static_method_buffer_compare_buf1_buf2" id="buffer_static_method_buffer_compare_buf1_buf2">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The arguments can now be <code>Uint8Array</code>s.</p></td></tr>
|
||
<tr><td>v0.11.13</td>
|
||
<td><p><span>Added in: v0.11.13</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>buf1</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a></li>
|
||
<li><code>buf2</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a></li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Either <code>-1</code>, <code>0</code>, or <code>1</code>, depending on the result of the
|
||
comparison. See <a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf.compare()</code></a> for details.</li>
|
||
</ul>
|
||
<p>Compares <code>buf1</code> to <code>buf2</code>, typically for the purpose of sorting arrays of
|
||
<code>Buffer</code> instances. This is equivalent to calling
|
||
<a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf1.compare(buf2)</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'1234'</span>);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'0123'</span>);
|
||
<span class="hljs-keyword">const</span> arr = [buf1, buf2];
|
||
|
||
<span class="hljs-built_in">console</span>.log(arr.sort(Buffer.compare));
|
||
<span class="hljs-comment">// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]</span>
|
||
<span class="hljs-comment">// (This result is equal to: [buf2, buf1].)</span></code></pre>
|
||
<h3>Static method: <code>Buffer.concat(list[, totalLength])</code><span><a class="mark" href="#buffer_static_method_buffer_concat_list_totallength" id="buffer_static_method_buffer_concat_list_totallength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The elements of <code>list</code> can now be <code>Uint8Array</code>s.</p></td></tr>
|
||
<tr><td>v0.7.11</td>
|
||
<td><p><span>Added in: v0.7.11</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>list</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array[]></a> List of <code>Buffer</code> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a>
|
||
instances to concatenate.</li>
|
||
<li><code>totalLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Total length of the <code>Buffer</code> instances in <code>list</code>
|
||
when concatenated.</li>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a></li>
|
||
</ul>
|
||
<p>Returns a new <code>Buffer</code> which is the result of concatenating all the <code>Buffer</code>
|
||
instances in the <code>list</code> together.</p>
|
||
<p>If the list has no items, or if the <code>totalLength</code> is 0, then a new zero-length
|
||
<code>Buffer</code> is returned.</p>
|
||
<p>If <code>totalLength</code> is not provided, it is calculated from the <code>Buffer</code> instances
|
||
in <code>list</code> by adding their lengths.</p>
|
||
<p>If <code>totalLength</code> is provided, it is coerced to an unsigned integer. If the
|
||
combined length of the <code>Buffer</code>s in <code>list</code> exceeds <code>totalLength</code>, the result is
|
||
truncated to <code>totalLength</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Create a single `Buffer` from a list of three `Buffer` instances.</span>
|
||
|
||
<span class="hljs-keyword">const</span> buf1 = Buffer.alloc(<span class="hljs-number">10</span>);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.alloc(<span class="hljs-number">14</span>);
|
||
<span class="hljs-keyword">const</span> buf3 = Buffer.alloc(<span class="hljs-number">18</span>);
|
||
<span class="hljs-keyword">const</span> totalLength = buf1.length + buf2.length + buf3.length;
|
||
|
||
<span class="hljs-built_in">console</span>.log(totalLength);
|
||
<span class="hljs-comment">// Prints: 42</span>
|
||
|
||
<span class="hljs-keyword">const</span> bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
|
||
|
||
<span class="hljs-built_in">console</span>.log(bufA);
|
||
<span class="hljs-comment">// Prints: <Buffer 00 00 00 00 ...></span>
|
||
<span class="hljs-built_in">console</span>.log(bufA.length);
|
||
<span class="hljs-comment">// Prints: 42</span></code></pre>
|
||
<p><code>Buffer.concat()</code> may also use the internal <code>Buffer</code> pool like
|
||
<a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> does.</p>
|
||
<h3>Static method: <code>Buffer.from(array)</code><span><a class="mark" href="#buffer_static_method_buffer_from_array" id="buffer_static_method_buffer_from_array">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.10.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>array</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer[]></a></li>
|
||
</ul>
|
||
<p>Allocates a new <code>Buffer</code> using an <code>array</code> of bytes in the range <code>0</code> – <code>255</code>.
|
||
Array entries outside that range will be truncated to fit into it.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.</span>
|
||
<span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x62</span>, <span class="hljs-number">0x75</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x65</span>, <span class="hljs-number">0x72</span>]);</code></pre>
|
||
<p>A <code>TypeError</code> will be thrown if <code>array</code> is not an <code>Array</code> or another type
|
||
appropriate for <code>Buffer.from()</code> variants.</p>
|
||
<p><code>Buffer.from(array)</code> and <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string)</code></a> may also use the internal
|
||
<code>Buffer</code> pool like <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> does.</p>
|
||
<h3>Static method: <code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length" id="buffer_static_method_buffer_from_arraybuffer_byteoffset_length">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.10.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>arrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type"><ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer" class="type"><SharedArrayBuffer></a> An <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>,
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a>, for example the <code>.buffer</code> property of a
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>.</li>
|
||
<li><code>byteOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Index of first byte to expose. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to expose.
|
||
<strong>Default:</strong> <code>arrayBuffer.byteLength - byteOffset</code>.</li>
|
||
</ul>
|
||
<p>This creates a view of the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> without copying the underlying
|
||
memory. For example, when passed a reference to the <code>.buffer</code> property of a
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance, the newly created <code>Buffer</code> will share the same
|
||
allocated memory as the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">2</span>);
|
||
|
||
arr[<span class="hljs-number">0</span>] = <span class="hljs-number">5000</span>;
|
||
arr[<span class="hljs-number">1</span>] = <span class="hljs-number">4000</span>;
|
||
|
||
<span class="hljs-comment">// Shares memory with `arr`.</span>
|
||
<span class="hljs-keyword">const</span> buf = Buffer.from(arr.buffer);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 88 13 a0 0f></span>
|
||
|
||
<span class="hljs-comment">// Changing the original Uint16Array changes the Buffer also.</span>
|
||
arr[<span class="hljs-number">1</span>] = <span class="hljs-number">6000</span>;
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 88 13 70 17></span></code></pre>
|
||
<p>The optional <code>byteOffset</code> and <code>length</code> arguments specify a memory range within
|
||
the <code>arrayBuffer</code> that will be shared by the <code>Buffer</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>);
|
||
<span class="hljs-keyword">const</span> buf = Buffer.from(ab, <span class="hljs-number">0</span>, <span class="hljs-number">2</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.length);
|
||
<span class="hljs-comment">// Prints: 2</span></code></pre>
|
||
<p>A <code>TypeError</code> will be thrown if <code>arrayBuffer</code> is not an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> or a
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> or another type appropriate for <code>Buffer.from()</code>
|
||
variants.</p>
|
||
<h3>Static method: <code>Buffer.from(buffer)</code><span><a class="mark" href="#buffer_static_method_buffer_from_buffer" id="buffer_static_method_buffer_from_buffer">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.10.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> An existing <code>Buffer</code> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> from
|
||
which to copy data.</li>
|
||
</ul>
|
||
<p>Copies the passed <code>buffer</code> data onto a new <code>Buffer</code> instance.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'buffer'</span>);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from(buf1);
|
||
|
||
buf1[<span class="hljs-number">0</span>] = <span class="hljs-number">0x61</span>;
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1.toString());
|
||
<span class="hljs-comment">// Prints: auffer</span>
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString());
|
||
<span class="hljs-comment">// Prints: buffer</span></code></pre>
|
||
<p>A <code>TypeError</code> will be thrown if <code>buffer</code> is not a <code>Buffer</code> or another type
|
||
appropriate for <code>Buffer.from()</code> variants.</p>
|
||
<h3>Static method: <code>Buffer.from(object[, offsetOrEncoding[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_object_offsetorencoding_length" id="buffer_static_method_buffer_from_object_offsetorencoding_length">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v8.2.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>object</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type"><Object></a> An object supporting <code>Symbol.toPrimitive</code> or <code>valueOf()</code>.</li>
|
||
<li><code>offsetOrEncoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> A byte-offset or encoding.</li>
|
||
<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> A length.</li>
|
||
</ul>
|
||
<p>For objects whose <code>valueOf()</code> function returns a value not strictly equal to
|
||
<code>object</code>, returns <code>Buffer.from(object.valueOf(), offsetOrEncoding, length)</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'this is a test'</span>));
|
||
<span class="hljs-comment">// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74></span></code></pre>
|
||
<p>For objects that support <code>Symbol.toPrimitive</code>, returns
|
||
<code>Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding)</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Foo</span> </span>{
|
||
[<span class="hljs-built_in">Symbol</span>.toPrimitive]() {
|
||
<span class="hljs-keyword">return</span> <span class="hljs-string">'this is a test'</span>;
|
||
}
|
||
}
|
||
|
||
<span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-keyword">new</span> Foo(), <span class="hljs-string">'utf8'</span>);
|
||
<span class="hljs-comment">// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74></span></code></pre>
|
||
<p>A <code>TypeError</code> will be thrown if <code>object</code> does not have the mentioned methods or
|
||
is not of another type appropriate for <code>Buffer.from()</code> variants.</p>
|
||
<h3>Static method: <code>Buffer.from(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_from_string_encoding" id="buffer_static_method_buffer_from_string_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.10.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> A string to encode.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> The encoding of <code>string</code>. <strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
</ul>
|
||
<p>Creates a new <code>Buffer</code> containing <code>string</code>. The <code>encoding</code> parameter identifies
|
||
the character encoding to be used when converting <code>string</code> into bytes.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'this is a tést'</span>);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'7468697320697320612074c3a97374'</span>, <span class="hljs-string">'hex'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1.toString());
|
||
<span class="hljs-comment">// Prints: this is a tést</span>
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString());
|
||
<span class="hljs-comment">// Prints: this is a tést</span>
|
||
<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'latin1'</span>));
|
||
<span class="hljs-comment">// Prints: this is a tést</span></code></pre>
|
||
<p>A <code>TypeError</code> will be thrown if <code>string</code> is not a string or another type
|
||
appropriate for <code>Buffer.from()</code> variants.</p>
|
||
<h3>Static method: <code>Buffer.isBuffer(obj)</code><span><a class="mark" href="#buffer_static_method_buffer_isbuffer_obj" id="buffer_static_method_buffer_isbuffer_obj">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.1.101</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>obj</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type"><Object></a></li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type"><boolean></a></li>
|
||
</ul>
|
||
<p>Returns <code>true</code> if <code>obj</code> is a <code>Buffer</code>, <code>false</code> otherwise.</p>
|
||
<h3>Static method: <code>Buffer.isEncoding(encoding)</code><span><a class="mark" href="#buffer_static_method_buffer_isencoding_encoding" id="buffer_static_method_buffer_isencoding_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.9.1</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> A character encoding name to check.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type"><boolean></a></li>
|
||
</ul>
|
||
<p>Returns <code>true</code> if <code>encoding</code> is the name of a supported character encoding,
|
||
or <code>false</code> otherwise.</p>
|
||
<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'utf-8'</span>));
|
||
<span class="hljs-comment">// Prints: true</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'hex'</span>));
|
||
<span class="hljs-comment">// Prints: true</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'utf/8'</span>));
|
||
<span class="hljs-comment">// Prints: false</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">''</span>));
|
||
<span class="hljs-comment">// Prints: false</span></code></pre>
|
||
<h3>Class property: <code>Buffer.poolSize</code><span><a class="mark" href="#buffer_class_property_buffer_poolsize" id="buffer_class_property_buffer_poolsize">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.11.3</span>
|
||
</div>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <strong>Default:</strong> <code>8192</code></li>
|
||
</ul>
|
||
<p>This is the size (in bytes) of pre-allocated internal <code>Buffer</code> instances used
|
||
for pooling. This value may be modified.</p>
|
||
<h3><code>buf[index]</code><span><a class="mark" href="#buffer_buf_index" id="buffer_buf_index">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
|
||
</div>
|
||
<ul>
|
||
<li><code>index</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>The index operator <code>[index]</code> can be used to get and set the octet at position
|
||
<code>index</code> in <code>buf</code>. The values refer to individual bytes, so the legal value
|
||
range is between <code>0x00</code> and <code>0xFF</code> (hex) or <code>0</code> and <code>255</code> (decimal).</p>
|
||
<p>This operator is inherited from <code>Uint8Array</code>, so its behavior on out-of-bounds
|
||
access is the same as <code>Uint8Array</code>. In other words, <code>buf[index]</code> returns
|
||
<code>undefined</code> when <code>index</code> is negative or greater or equal to <code>buf.length</code>, and
|
||
<code>buf[index] = value</code> does not modify the buffer if <code>index</code> is negative or
|
||
<code>>= buf.length</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Copy an ASCII string into a `Buffer` one byte at a time.</span>
|
||
<span class="hljs-comment">// (This only works for ASCII-only strings. In general, one should use</span>
|
||
<span class="hljs-comment">// `Buffer.from()` to perform this conversion.)</span>
|
||
|
||
<span class="hljs-keyword">const</span> str = <span class="hljs-string">'Node.js'</span>;
|
||
<span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(str.length);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i < str.length; i++) {
|
||
buf[i] = str.charCodeAt(i);
|
||
}
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'utf8'</span>));
|
||
<span class="hljs-comment">// Prints: Node.js</span></code></pre>
|
||
<h3><code>buf.buffer</code><span><a class="mark" href="#buffer_buf_buffer" id="buffer_buf_buffer">#</a></span></h3>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type"><ArrayBuffer></a> The underlying <code>ArrayBuffer</code> object based on which this <code>Buffer</code>
|
||
object is created.</li>
|
||
</ul>
|
||
<p>This <code>ArrayBuffer</code> is not guaranteed to correspond exactly to the original
|
||
<code>Buffer</code>. See the notes on <code>buf.byteOffset</code> for details.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> arrayBuffer = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">16</span>);
|
||
<span class="hljs-keyword">const</span> buffer = Buffer.from(arrayBuffer);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buffer.buffer === arrayBuffer);
|
||
<span class="hljs-comment">// Prints: true</span></code></pre>
|
||
<h3><code>buf.byteOffset</code><span><a class="mark" href="#buffer_buf_byteoffset" id="buffer_buf_byteoffset">#</a></span></h3>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The <code>byteOffset</code> of the <code>Buffer</code>s underlying <code>ArrayBuffer</code> object.</li>
|
||
</ul>
|
||
<p>When setting <code>byteOffset</code> in <code>Buffer.from(ArrayBuffer, byteOffset, length)</code>,
|
||
or sometimes when allocating a <code>Buffer</code> smaller than <code>Buffer.poolSize</code>, the
|
||
buffer does not start from a zero offset on the underlying <code>ArrayBuffer</code>.</p>
|
||
<p>This can cause problems when accessing the underlying <code>ArrayBuffer</code> directly
|
||
using <code>buf.buffer</code>, as other parts of the <code>ArrayBuffer</code> may be unrelated
|
||
to the <code>Buffer</code> object itself.</p>
|
||
<p>A common issue when creating a <code>TypedArray</code> object that shares its memory with
|
||
a <code>Buffer</code> is that in this case one needs to specify the <code>byteOffset</code> correctly:</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Create a buffer smaller than `Buffer.poolSize`.</span>
|
||
<span class="hljs-keyword">const</span> nodeBuffer = <span class="hljs-keyword">new</span> Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
|
||
|
||
<span class="hljs-comment">// When casting the Node.js Buffer to an Int8Array, use the byteOffset</span>
|
||
<span class="hljs-comment">// to refer only to the part of `nodeBuffer.buffer` that contains the memory</span>
|
||
<span class="hljs-comment">// for `nodeBuffer`.</span>
|
||
<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int8Array</span>(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);</code></pre>
|
||
<h3><code>buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])</code><span><a class="mark" href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend" id="buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The <code>target</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
|
||
<tr><td>v5.11.0</td>
|
||
<td><p>Additional parameters for specifying offsets are supported now.</p></td></tr>
|
||
<tr><td>v0.11.13</td>
|
||
<td><p><span>Added in: v0.11.13</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>target</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> A <code>Buffer</code> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> with which to
|
||
compare <code>buf</code>.</li>
|
||
<li><code>targetStart</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The offset within <code>target</code> at which to begin
|
||
comparison. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>targetEnd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The offset within <code>target</code> at which to end comparison
|
||
(not inclusive). <strong>Default:</strong> <code>target.length</code>.</li>
|
||
<li><code>sourceStart</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The offset within <code>buf</code> at which to begin comparison.
|
||
<strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>sourceEnd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The offset within <code>buf</code> at which to end comparison
|
||
(not inclusive). <strong>Default:</strong> <a href="#buffer_buf_length"><code>buf.length</code></a>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Compares <code>buf</code> with <code>target</code> and returns a number indicating whether <code>buf</code>
|
||
comes before, after, or is the same as <code>target</code> in sort order.
|
||
Comparison is based on the actual sequence of bytes in each <code>Buffer</code>.</p>
|
||
<ul>
|
||
<li><code>0</code> is returned if <code>target</code> is the same as <code>buf</code></li>
|
||
<li><code>1</code> is returned if <code>target</code> should come <em>before</em> <code>buf</code> when sorted.</li>
|
||
<li><code>-1</code> is returned if <code>target</code> should come <em>after</em> <code>buf</code> when sorted.</li>
|
||
</ul>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'ABC'</span>);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'BCD'</span>);
|
||
<span class="hljs-keyword">const</span> buf3 = Buffer.from(<span class="hljs-string">'ABCD'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1.compare(buf1));
|
||
<span class="hljs-comment">// Prints: 0</span>
|
||
<span class="hljs-built_in">console</span>.log(buf1.compare(buf2));
|
||
<span class="hljs-comment">// Prints: -1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf1.compare(buf3));
|
||
<span class="hljs-comment">// Prints: -1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf2.compare(buf1));
|
||
<span class="hljs-comment">// Prints: 1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf2.compare(buf3));
|
||
<span class="hljs-comment">// Prints: 1</span>
|
||
<span class="hljs-built_in">console</span>.log([buf1, buf2, buf3].sort(Buffer.compare));
|
||
<span class="hljs-comment">// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]</span>
|
||
<span class="hljs-comment">// (This result is equal to: [buf1, buf3, buf2].)</span></code></pre>
|
||
<p>The optional <code>targetStart</code>, <code>targetEnd</code>, <code>sourceStart</code>, and <code>sourceEnd</code>
|
||
arguments can be used to limit the comparison to specific ranges within <code>target</code>
|
||
and <code>buf</code> respectively.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">9</span>, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>));
|
||
<span class="hljs-comment">// Prints: 0</span>
|
||
<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>, <span class="hljs-number">4</span>));
|
||
<span class="hljs-comment">// Prints: -1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>));
|
||
<span class="hljs-comment">// Prints: 1</span></code></pre>
|
||
<p><a href="errors.html#ERR_OUT_OF_RANGE"><code>ERR_OUT_OF_RANGE</code></a> is thrown if <code>targetStart < 0</code>, <code>sourceStart < 0</code>,
|
||
<code>targetEnd > target.byteLength</code>, or <code>sourceEnd > source.byteLength</code>.</p>
|
||
<h3><code>buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])</code><span><a class="mark" href="#buffer_buf_copy_target_targetstart_sourcestart_sourceend" id="buffer_buf_copy_target_targetstart_sourcestart_sourceend">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.1.90</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>target</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> A <code>Buffer</code> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> to copy into.</li>
|
||
<li><code>targetStart</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The offset within <code>target</code> at which to begin
|
||
writing. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>sourceStart</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The offset within <code>buf</code> from which to begin copying.
|
||
<strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>sourceEnd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The offset within <code>buf</code> at which to stop copying (not
|
||
inclusive). <strong>Default:</strong> <a href="#buffer_buf_length"><code>buf.length</code></a>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The number of bytes copied.</li>
|
||
</ul>
|
||
<p>Copies data from a region of <code>buf</code> to a region in <code>target</code>, even if the <code>target</code>
|
||
memory region overlaps with <code>buf</code>.</p>
|
||
<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set"><code>TypedArray#set()</code></a> performs the same operation, and is available for all
|
||
TypedArrays, including Node.js <code>Buffer</code>s, although it takes different
|
||
function arguments.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Create two `Buffer` instances.</span>
|
||
<span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.allocUnsafe(<span class="hljs-number">26</span>).fill(<span class="hljs-string">'!'</span>);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">26</span>; i++) {
|
||
<span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
|
||
buf1[i] = i + <span class="hljs-number">97</span>;
|
||
}
|
||
|
||
<span class="hljs-comment">// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.</span>
|
||
buf1.copy(buf2, <span class="hljs-number">8</span>, <span class="hljs-number">16</span>, <span class="hljs-number">20</span>);
|
||
<span class="hljs-comment">// This is equivalent to:</span>
|
||
<span class="hljs-comment">// buf2.set(buf1.subarray(16, 20), 8);</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">25</span>));
|
||
<span class="hljs-comment">// Prints: !!!!!!!!qrst!!!!!!!!!!!!!</span></code></pre>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` and copy data from one region to an overlapping region</span>
|
||
<span class="hljs-comment">// within the same `Buffer`.</span>
|
||
|
||
<span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">26</span>; i++) {
|
||
<span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
|
||
buf[i] = i + <span class="hljs-number">97</span>;
|
||
}
|
||
|
||
buf.copy(buf, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">10</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.toString());
|
||
<span class="hljs-comment">// Prints: efghijghijklmnopqrstuvwxyz</span></code></pre>
|
||
<h3><code>buf.entries()</code><span><a class="mark" href="#buffer_buf_entries" id="buffer_buf_entries">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v1.1.0</span>
|
||
</div>
|
||
<ul>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type"><Iterator></a></li>
|
||
</ul>
|
||
<p>Creates and returns an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">iterator</a> of <code>[index, byte]</code> pairs from the contents
|
||
of <code>buf</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Log the entire contents of a `Buffer`.</span>
|
||
|
||
<span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> pair <span class="hljs-keyword">of</span> buf.entries()) {
|
||
<span class="hljs-built_in">console</span>.log(pair);
|
||
}
|
||
<span class="hljs-comment">// Prints:</span>
|
||
<span class="hljs-comment">// [0, 98]</span>
|
||
<span class="hljs-comment">// [1, 117]</span>
|
||
<span class="hljs-comment">// [2, 102]</span>
|
||
<span class="hljs-comment">// [3, 102]</span>
|
||
<span class="hljs-comment">// [4, 101]</span>
|
||
<span class="hljs-comment">// [5, 114]</span></code></pre>
|
||
<h3><code>buf.equals(otherBuffer)</code><span><a class="mark" href="#buffer_buf_equals_otherbuffer" id="buffer_buf_equals_otherbuffer">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The arguments can now be <code>Uint8Array</code>s.</p></td></tr>
|
||
<tr><td>v0.11.13</td>
|
||
<td><p><span>Added in: v0.11.13</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>otherBuffer</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> A <code>Buffer</code> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> with which to
|
||
compare <code>buf</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type"><boolean></a></li>
|
||
</ul>
|
||
<p>Returns <code>true</code> if both <code>buf</code> and <code>otherBuffer</code> have exactly the same bytes,
|
||
<code>false</code> otherwise. Equivalent to
|
||
<a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf.compare(otherBuffer) === 0</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'ABC'</span>);
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'414243'</span>, <span class="hljs-string">'hex'</span>);
|
||
<span class="hljs-keyword">const</span> buf3 = Buffer.from(<span class="hljs-string">'ABCD'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1.equals(buf2));
|
||
<span class="hljs-comment">// Prints: true</span>
|
||
<span class="hljs-built_in">console</span>.log(buf1.equals(buf3));
|
||
<span class="hljs-comment">// Prints: false</span></code></pre>
|
||
<h3><code>buf.fill(value[, offset[, end]][, encoding])</code><span><a class="mark" href="#buffer_buf_fill_value_offset_end_encoding" id="buffer_buf_fill_value_offset_end_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v11.0.0</td>
|
||
<td><p>Throws <code>ERR_OUT_OF_RANGE</code> instead of <code>ERR_INDEX_OUT_OF_RANGE</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Negative <code>end</code> values throw an <code>ERR_INDEX_OUT_OF_RANGE</code> error.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Attempting to fill a non-zero length buffer with a zero length buffer triggers a thrown exception.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Specifying an invalid string for <code>value</code> triggers a thrown exception.</p></td></tr>
|
||
<tr><td>v5.7.0</td>
|
||
<td><p>The <code>encoding</code> parameter is supported now.</p></td></tr>
|
||
<tr><td>v0.5.0</td>
|
||
<td><p><span>Added in: v0.5.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> | <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The value with which to fill <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to fill <code>buf</code>.
|
||
<strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where to stop filling <code>buf</code> (not inclusive). <strong>Default:</strong>
|
||
<a href="#buffer_buf_length"><code>buf.length</code></a>.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> The encoding for <code>value</code> if <code>value</code> is a string.
|
||
<strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> A reference to <code>buf</code>.</li>
|
||
</ul>
|
||
<p>Fills <code>buf</code> with the specified <code>value</code>. If the <code>offset</code> and <code>end</code> are not given,
|
||
the entire <code>buf</code> will be filled:</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Fill a `Buffer` with the ASCII character 'h'.</span>
|
||
|
||
<span class="hljs-keyword">const</span> b = Buffer.allocUnsafe(<span class="hljs-number">50</span>).fill(<span class="hljs-string">'h'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(b.toString());
|
||
<span class="hljs-comment">// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh</span></code></pre>
|
||
<p><code>value</code> is coerced to a <code>uint32</code> value if it is not a string, <code>Buffer</code>, or
|
||
integer. If the resulting integer is greater than <code>255</code> (decimal), <code>buf</code> will be
|
||
filled with <code>value & 255</code>.</p>
|
||
<p>If the final write of a <code>fill()</code> operation falls on a multi-byte character,
|
||
then only the bytes of that character that fit into <code>buf</code> are written:</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Fill a `Buffer` with character that takes up two bytes in UTF-8.</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(Buffer.allocUnsafe(<span class="hljs-number">5</span>).fill(<span class="hljs-string">'\u0222'</span>));
|
||
<span class="hljs-comment">// Prints: <Buffer c8 a2 c8 a2 c8></span></code></pre>
|
||
<p>If <code>value</code> contains invalid characters, it is truncated; if no valid
|
||
fill data remains, an exception is thrown:</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">5</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'a'</span>));
|
||
<span class="hljs-comment">// Prints: <Buffer 61 61 61 61 61></span>
|
||
<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'aazz'</span>, <span class="hljs-string">'hex'</span>));
|
||
<span class="hljs-comment">// Prints: <Buffer aa aa aa aa aa></span>
|
||
<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'zz'</span>, <span class="hljs-string">'hex'</span>));
|
||
<span class="hljs-comment">// Throws an exception.</span></code></pre>
|
||
<h3><code>buf.includes(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_includes_value_byteoffset_encoding" id="buffer_buf_includes_value_byteoffset_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.3.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> | <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> What to search for.</li>
|
||
<li><code>byteOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where to begin searching in <code>buf</code>. If negative, then
|
||
offset is calculated from the end of <code>buf</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> If <code>value</code> is a string, this is its encoding.
|
||
<strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type"><boolean></a> <code>true</code> if <code>value</code> was found in <code>buf</code>, <code>false</code> otherwise.</li>
|
||
</ul>
|
||
<p>Equivalent to <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf() !== -1</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this is a buffer'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'this'</span>));
|
||
<span class="hljs-comment">// Prints: true</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'is'</span>));
|
||
<span class="hljs-comment">// Prints: true</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer'</span>)));
|
||
<span class="hljs-comment">// Prints: true</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-number">97</span>));
|
||
<span class="hljs-comment">// Prints: true (97 is the decimal ASCII value for 'a')</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer example'</span>)));
|
||
<span class="hljs-comment">// Prints: false</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer example'</span>).slice(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
|
||
<span class="hljs-comment">// Prints: true</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'this'</span>, <span class="hljs-number">4</span>));
|
||
<span class="hljs-comment">// Prints: false</span></code></pre>
|
||
<h3><code>buf.indexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_indexof_value_byteoffset_encoding" id="buffer_buf_indexof_value_byteoffset_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The <code>value</code> can now be a <code>Uint8Array</code>.</p></td></tr>
|
||
<tr><td>v5.7.0, v4.4.0</td>
|
||
<td><p>When <code>encoding</code> is being passed, the <code>byteOffset</code> parameter is no longer required.</p></td></tr>
|
||
<tr><td>v1.5.0</td>
|
||
<td><p><span>Added in: v1.5.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> | <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> What to search for.</li>
|
||
<li><code>byteOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where to begin searching in <code>buf</code>. If negative, then
|
||
offset is calculated from the end of <code>buf</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> If <code>value</code> is a string, this is the encoding used to
|
||
determine the binary representation of the string that will be searched for in
|
||
<code>buf</code>. <strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The index of the first occurrence of <code>value</code> in <code>buf</code>, or
|
||
<code>-1</code> if <code>buf</code> does not contain <code>value</code>.</li>
|
||
</ul>
|
||
<p>If <code>value</code> is:</p>
|
||
<ul>
|
||
<li>a string, <code>value</code> is interpreted according to the character encoding in
|
||
<code>encoding</code>.</li>
|
||
<li>a <code>Buffer</code> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a>, <code>value</code> will be used in its entirety.
|
||
To compare a partial <code>Buffer</code>, use <a href="#buffer_buf_slice_start_end"><code>buf.slice()</code></a>.</li>
|
||
<li>a number, <code>value</code> will be interpreted as an unsigned 8-bit integer
|
||
value between <code>0</code> and <code>255</code>.</li>
|
||
</ul>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this is a buffer'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-string">'this'</span>));
|
||
<span class="hljs-comment">// Prints: 0</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-string">'is'</span>));
|
||
<span class="hljs-comment">// Prints: 2</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer'</span>)));
|
||
<span class="hljs-comment">// Prints: 8</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-number">97</span>));
|
||
<span class="hljs-comment">// Prints: 8 (97 is the decimal ASCII value for 'a')</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer example'</span>)));
|
||
<span class="hljs-comment">// Prints: -1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer example'</span>).slice(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
|
||
<span class="hljs-comment">// Prints: 8</span>
|
||
|
||
<span class="hljs-keyword">const</span> utf16Buffer = Buffer.from(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(utf16Buffer.indexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf16le'</span>));
|
||
<span class="hljs-comment">// Prints: 4</span>
|
||
<span class="hljs-built_in">console</span>.log(utf16Buffer.indexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">-4</span>, <span class="hljs-string">'utf16le'</span>));
|
||
<span class="hljs-comment">// Prints: 6</span></code></pre>
|
||
<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a
|
||
<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,
|
||
an integer between 0 and 255.</p>
|
||
<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. If the result
|
||
of coercion is <code>NaN</code> or <code>0</code>, then the entire buffer will be searched. This
|
||
behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>String#indexOf()</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> b = Buffer.from(<span class="hljs-string">'abcdef'</span>);
|
||
|
||
<span class="hljs-comment">// Passing a value that's a number, but not a valid byte.</span>
|
||
<span class="hljs-comment">// Prints: 2, equivalent to searching for 99 or 'c'.</span>
|
||
<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-number">99.9</span>));
|
||
<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
|
||
|
||
<span class="hljs-comment">// Passing a byteOffset that coerces to NaN or 0.</span>
|
||
<span class="hljs-comment">// Prints: 1, searching the whole buffer.</span>
|
||
<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
|
||
<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, {}));
|
||
<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
|
||
<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, []));</code></pre>
|
||
<p>If <code>value</code> is an empty string or empty <code>Buffer</code> and <code>byteOffset</code> is less
|
||
than <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code>value</code> is empty and
|
||
<code>byteOffset</code> is at least <code>buf.length</code>, <code>buf.length</code> will be returned.</p>
|
||
<h3><code>buf.keys()</code><span><a class="mark" href="#buffer_buf_keys" id="buffer_buf_keys">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v1.1.0</span>
|
||
</div>
|
||
<ul>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type"><Iterator></a></li>
|
||
</ul>
|
||
<p>Creates and returns an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">iterator</a> of <code>buf</code> keys (indices).</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> key <span class="hljs-keyword">of</span> buf.keys()) {
|
||
<span class="hljs-built_in">console</span>.log(key);
|
||
}
|
||
<span class="hljs-comment">// Prints:</span>
|
||
<span class="hljs-comment">// 0</span>
|
||
<span class="hljs-comment">// 1</span>
|
||
<span class="hljs-comment">// 2</span>
|
||
<span class="hljs-comment">// 3</span>
|
||
<span class="hljs-comment">// 4</span>
|
||
<span class="hljs-comment">// 5</span></code></pre>
|
||
<h3><code>buf.lastIndexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_lastindexof_value_byteoffset_encoding" id="buffer_buf_lastindexof_value_byteoffset_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The <code>value</code> can now be a <code>Uint8Array</code>.</p></td></tr>
|
||
<tr><td>v6.0.0</td>
|
||
<td><p><span>Added in: v6.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> | <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> What to search for.</li>
|
||
<li><code>byteOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where to begin searching in <code>buf</code>. If negative, then
|
||
offset is calculated from the end of <code>buf</code>. <strong>Default:</strong>
|
||
<code>buf.length - 1</code>.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> If <code>value</code> is a string, this is the encoding used to
|
||
determine the binary representation of the string that will be searched for in
|
||
<code>buf</code>. <strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The index of the last occurrence of <code>value</code> in <code>buf</code>, or
|
||
<code>-1</code> if <code>buf</code> does not contain <code>value</code>.</li>
|
||
</ul>
|
||
<p>Identical to <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf()</code></a>, except the last occurrence of <code>value</code> is found
|
||
rather than the first occurrence.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this buffer is a buffer'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'this'</span>));
|
||
<span class="hljs-comment">// Prints: 0</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>));
|
||
<span class="hljs-comment">// Prints: 17</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(Buffer.from(<span class="hljs-string">'buffer'</span>)));
|
||
<span class="hljs-comment">// Prints: 17</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-number">97</span>));
|
||
<span class="hljs-comment">// Prints: 15 (97 is the decimal ASCII value for 'a')</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(Buffer.from(<span class="hljs-string">'yolo'</span>)));
|
||
<span class="hljs-comment">// Prints: -1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">5</span>));
|
||
<span class="hljs-comment">// Prints: 5</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">4</span>));
|
||
<span class="hljs-comment">// Prints: -1</span>
|
||
|
||
<span class="hljs-keyword">const</span> utf16Buffer = Buffer.from(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(utf16Buffer.lastIndexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'utf16le'</span>));
|
||
<span class="hljs-comment">// Prints: 6</span>
|
||
<span class="hljs-built_in">console</span>.log(utf16Buffer.lastIndexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">-5</span>, <span class="hljs-string">'utf16le'</span>));
|
||
<span class="hljs-comment">// Prints: 4</span></code></pre>
|
||
<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a
|
||
<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,
|
||
an integer between 0 and 255.</p>
|
||
<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. Any arguments
|
||
that coerce to <code>NaN</code>, like <code>{}</code> or <code>undefined</code>, will search the whole buffer.
|
||
This behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf"><code>String#lastIndexOf()</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> b = Buffer.from(<span class="hljs-string">'abcdef'</span>);
|
||
|
||
<span class="hljs-comment">// Passing a value that's a number, but not a valid byte.</span>
|
||
<span class="hljs-comment">// Prints: 2, equivalent to searching for 99 or 'c'.</span>
|
||
<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-number">99.9</span>));
|
||
<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
|
||
|
||
<span class="hljs-comment">// Passing a byteOffset that coerces to NaN.</span>
|
||
<span class="hljs-comment">// Prints: 1, searching the whole buffer.</span>
|
||
<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
|
||
<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, {}));
|
||
|
||
<span class="hljs-comment">// Passing a byteOffset that coerces to 0.</span>
|
||
<span class="hljs-comment">// Prints: -1, equivalent to passing 0.</span>
|
||
<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
|
||
<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, []));</code></pre>
|
||
<p>If <code>value</code> is an empty string or empty <code>Buffer</code>, <code>byteOffset</code> will be returned.</p>
|
||
<h3><code>buf.length</code><span><a class="mark" href="#buffer_buf_length" id="buffer_buf_length">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.1.90</span>
|
||
</div>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Returns the number of bytes in <code>buf</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` and write a shorter string to it using UTF-8.</span>
|
||
|
||
<span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">1234</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.length);
|
||
<span class="hljs-comment">// Prints: 1234</span>
|
||
|
||
buf.write(<span class="hljs-string">'some string'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf8'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.length);
|
||
<span class="hljs-comment">// Prints: 1234</span></code></pre>
|
||
<h3><code>buf.parent</code><span><a class="mark" href="#buffer_buf_parent" id="buffer_buf_parent">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Deprecated since: v8.0.0</span>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_buf_buffer"><code>buf.buffer</code></a> instead.</div><p></p>
|
||
<p>The <code>buf.parent</code> property is a deprecated alias for <code>buf.buffer</code>.</p>
|
||
<h3><code>buf.readBigInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64be_offset" id="buffer_buf_readbigint64be_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v12.0.0, v10.20.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a></li>
|
||
</ul>
|
||
<p>Reads a signed, big-endian 64-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed
|
||
values.</p>
|
||
<h3><code>buf.readBigInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64le_offset" id="buffer_buf_readbigint64le_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v12.0.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a></li>
|
||
</ul>
|
||
<p>Reads a signed, little-endian 64-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed
|
||
values.</p>
|
||
<h3><code>buf.readBigUInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64be_offset" id="buffer_buf_readbiguint64be_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readBigUint64BE()</code>.</p></td></tr>
|
||
<tr><td>v12.0.0</td>
|
||
<td><p><span>Added in: v12.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a></li>
|
||
</ul>
|
||
<p>Reads an unsigned, big-endian 64-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readBigUInt64BE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 4294967295n</span></code></pre>
|
||
<h3><code>buf.readBigUInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64le_offset" id="buffer_buf_readbiguint64le_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readBigUint64LE()</code>.</p></td></tr>
|
||
<tr><td>v12.0.0, v10.20.0</td>
|
||
<td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a></li>
|
||
</ul>
|
||
<p>Reads an unsigned, little-endian 64-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readBigUInt64LE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 18446744069414584320n</span></code></pre>
|
||
<h3><code>buf.readDoubleBE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublebe_offset" id="buffer_buf_readdoublebe_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a></li>
|
||
</ul>
|
||
<p>Reads a 64-bit, big-endian double from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readDoubleBE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 8.20788039913184e-304</span></code></pre>
|
||
<h3><code>buf.readDoubleLE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublele_offset" id="buffer_buf_readdoublele_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a></li>
|
||
</ul>
|
||
<p>Reads a 64-bit, little-endian double from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readDoubleLE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 5.447603722011605e-270</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readDoubleLE(<span class="hljs-number">1</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readFloatBE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatbe_offset" id="buffer_buf_readfloatbe_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a></li>
|
||
</ul>
|
||
<p>Reads a 32-bit, big-endian float from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readFloatBE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 2.387939260590663e-38</span></code></pre>
|
||
<h3><code>buf.readFloatLE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatle_offset" id="buffer_buf_readfloatle_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a></li>
|
||
</ul>
|
||
<p>Reads a 32-bit, little-endian float from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readFloatLE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 1.539989614439558e-36</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readFloatLE(<span class="hljs-number">1</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readInt8([offset])</code><span><a class="mark" href="#buffer_buf_readint8_offset" id="buffer_buf_readint8_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.0</td>
|
||
<td><p><span>Added in: v0.5.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 1</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads a signed 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">-1</span>, <span class="hljs-number">5</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: -1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">1</span>));
|
||
<span class="hljs-comment">// Prints: 5</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">2</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readint16be_offset" id="buffer_buf_readint16be_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads a signed, big-endian 16-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt16BE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 5</span></code></pre>
|
||
<h3><code>buf.readInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readint16le_offset" id="buffer_buf_readint16le_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads a signed, little-endian 16-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt16LE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 1280</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt16LE(<span class="hljs-number">1</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readint32be_offset" id="buffer_buf_readint32be_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads a signed, big-endian 32-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt32BE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 5</span></code></pre>
|
||
<h3><code>buf.readInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readint32le_offset" id="buffer_buf_readint32le_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads a signed, little-endian 32-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt32LE(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 83886080</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readInt32LE(<span class="hljs-number">1</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintbe_offset_bytelength" id="buffer_buf_readintbe_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to read. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
|
||
and interprets the result as a big-endian, two's complement signed value
|
||
supporting up to 48 bits of accuracy.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 1234567890ab</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintle_offset_bytelength" id="buffer_buf_readintle_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to read. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
|
||
and interprets the result as a little-endian, two's complement signed value
|
||
supporting up to 48 bits of accuracy.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readIntLE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: -546f87a9cbee</span></code></pre>
|
||
<h3><code>buf.readUInt8([offset])</code><span><a class="mark" href="#buffer_buf_readuint8_offset" id="buffer_buf_readuint8_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readUint8()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.0</td>
|
||
<td><p><span>Added in: v0.5.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 1</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads an unsigned 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">-2</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">0</span>));
|
||
<span class="hljs-comment">// Prints: 1</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">1</span>));
|
||
<span class="hljs-comment">// Prints: 254</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">2</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readUInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16be_offset" id="buffer_buf_readuint16be_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readUint16BE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads an unsigned, big-endian 16-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt16BE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 1234</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt16BE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 3456</span></code></pre>
|
||
<h3><code>buf.readUInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16le_offset" id="buffer_buf_readuint16le_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readUint16LE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads an unsigned, little-endian 16-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 3412</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 5634</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">2</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readUInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32be_offset" id="buffer_buf_readuint32be_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readUint32BE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads an unsigned, big-endian 32-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt32BE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 12345678</span></code></pre>
|
||
<h3><code>buf.readUInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32le_offset" id="buffer_buf_readuint32le_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readUint32LE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads an unsigned, little-endian 32-bit integer from <code>buf</code> at the specified
|
||
<code>offset</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt32LE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 78563412</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readUInt32LE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readUIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintbe_offset_bytelength" id="buffer_buf_readuintbe_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readUintBE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to read. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
|
||
and interprets the result as an unsigned big-endian integer supporting
|
||
up to 48 bits of accuracy.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readUIntBE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: 1234567890ab</span>
|
||
<span class="hljs-built_in">console</span>.log(buf.readUIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
|
||
<h3><code>buf.readUIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintle_offset_bytelength" id="buffer_buf_readuintle_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.readUintLE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to read. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to read. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a></li>
|
||
</ul>
|
||
<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
|
||
and interprets the result as an unsigned, little-endian integer supporting
|
||
up to 48 bits of accuracy.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.readUIntLE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
|
||
<span class="hljs-comment">// Prints: ab9078563412</span></code></pre>
|
||
<h3><code>buf.subarray([start[, end]])</code><span><a class="mark" href="#buffer_buf_subarray_start_end" id="buffer_buf_subarray_start_end">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v3.0.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where the new <code>Buffer</code> will start. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where the new <code>Buffer</code> will end (not inclusive).
|
||
<strong>Default:</strong> <a href="#buffer_buf_length"><code>buf.length</code></a>.</li>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a></li>
|
||
</ul>
|
||
<p>Returns a new <code>Buffer</code> that references the same memory as the original, but
|
||
offset and cropped by the <code>start</code> and <code>end</code> indices.</p>
|
||
<p>Specifying <code>end</code> greater than <a href="#buffer_buf_length"><code>buf.length</code></a> will return the same result as
|
||
that of <code>end</code> equal to <a href="#buffer_buf_length"><code>buf.length</code></a>.</p>
|
||
<p>This method is inherited from <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray#subarray()</code></a>.</p>
|
||
<p>Modifying the new <code>Buffer</code> slice will modify the memory in the original <code>Buffer</code>
|
||
because the allocated memory of the two objects overlap.</p>
|
||
<pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte</span>
|
||
<span class="hljs-comment">// from the original `Buffer`.</span>
|
||
|
||
<span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">26</span>; i++) {
|
||
<span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
|
||
buf1[i] = i + <span class="hljs-number">97</span>;
|
||
}
|
||
|
||
<span class="hljs-keyword">const</span> buf2 = buf1.subarray(<span class="hljs-number">0</span>, <span class="hljs-number">3</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.length));
|
||
<span class="hljs-comment">// Prints: abc</span>
|
||
|
||
buf1[<span class="hljs-number">0</span>] = <span class="hljs-number">33</span>;
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.length));
|
||
<span class="hljs-comment">// Prints: !bc</span></code></pre>
|
||
<p>Specifying negative indexes causes the slice to be generated relative to the
|
||
end of <code>buf</code> rather than the beginning.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-6</span>, <span class="hljs-number">-1</span>).toString());
|
||
<span class="hljs-comment">// Prints: buffe</span>
|
||
<span class="hljs-comment">// (Equivalent to buf.subarray(0, 5).)</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-6</span>, <span class="hljs-number">-2</span>).toString());
|
||
<span class="hljs-comment">// Prints: buff</span>
|
||
<span class="hljs-comment">// (Equivalent to buf.subarray(0, 4).)</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-5</span>, <span class="hljs-number">-2</span>).toString());
|
||
<span class="hljs-comment">// Prints: uff</span>
|
||
<span class="hljs-comment">// (Equivalent to buf.subarray(1, 4).)</span></code></pre>
|
||
<h3><code>buf.slice([start[, end]])</code><span><a class="mark" href="#buffer_buf_slice_start_end" id="buffer_buf_slice_start_end">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v7.1.0, v6.9.2</td>
|
||
<td><p>Coercing the offsets to integers now handles values outside the 32-bit integer range properly.</p></td></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>All offsets are now coerced to integers before doing any calculations with them.</p></td></tr>
|
||
<tr><td>v0.3.0</td>
|
||
<td><p><span>Added in: v0.3.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where the new <code>Buffer</code> will start. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Where the new <code>Buffer</code> will end (not inclusive).
|
||
<strong>Default:</strong> <a href="#buffer_buf_length"><code>buf.length</code></a>.</li>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a></li>
|
||
</ul>
|
||
<p>Returns a new <code>Buffer</code> that references the same memory as the original, but
|
||
offset and cropped by the <code>start</code> and <code>end</code> indices.</p>
|
||
<p>This is the same behavior as <code>buf.subarray()</code>.</p>
|
||
<p>This method is not compatible with the <code>Uint8Array.prototype.slice()</code>,
|
||
which is a superclass of <code>Buffer</code>. To copy the slice, use
|
||
<code>Uint8Array.prototype.slice()</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
|
||
|
||
<span class="hljs-keyword">const</span> copiedBuf = <span class="hljs-built_in">Uint8Array</span>.prototype.slice.call(buf);
|
||
copiedBuf[<span class="hljs-number">0</span>]++;
|
||
<span class="hljs-built_in">console</span>.log(copiedBuf.toString());
|
||
<span class="hljs-comment">// Prints: cuffer</span>
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf.toString());
|
||
<span class="hljs-comment">// Prints: buffer</span></code></pre>
|
||
<h3><code>buf.swap16()</code><span><a class="mark" href="#buffer_buf_swap16" id="buffer_buf_swap16">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.10.0</span>
|
||
</div>
|
||
<ul>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> A reference to <code>buf</code>.</li>
|
||
</ul>
|
||
<p>Interprets <code>buf</code> as an array of unsigned 16-bit integers and swaps the
|
||
byte order <em>in-place</em>. Throws <a href="errors.html#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a>
|
||
is not a multiple of 2.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 01 02 03 04 05 06 07 08></span>
|
||
|
||
buf1.swap16();
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 02 01 04 03 06 05 08 07></span>
|
||
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
|
||
|
||
buf2.swap16();
|
||
<span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
|
||
<p>One convenient use of <code>buf.swap16()</code> is to perform a fast in-place conversion
|
||
between UTF-16 little-endian and UTF-16 big-endian:</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'This is little-endian UTF-16'</span>, <span class="hljs-string">'utf16le'</span>);
|
||
buf.swap16(); <span class="hljs-comment">// Convert to big-endian UTF-16 text.</span></code></pre>
|
||
<h3><code>buf.swap32()</code><span><a class="mark" href="#buffer_buf_swap32" id="buffer_buf_swap32">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.10.0</span>
|
||
</div>
|
||
<ul>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> A reference to <code>buf</code>.</li>
|
||
</ul>
|
||
<p>Interprets <code>buf</code> as an array of unsigned 32-bit integers and swaps the
|
||
byte order <em>in-place</em>. Throws <a href="errors.html#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a>
|
||
is not a multiple of 4.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 01 02 03 04 05 06 07 08></span>
|
||
|
||
buf1.swap32();
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 04 03 02 01 08 07 06 05></span>
|
||
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
|
||
|
||
buf2.swap32();
|
||
<span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
|
||
<h3><code>buf.swap64()</code><span><a class="mark" href="#buffer_buf_swap64" id="buffer_buf_swap64">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v6.3.0</span>
|
||
</div>
|
||
<ul>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> A reference to <code>buf</code>.</li>
|
||
</ul>
|
||
<p>Interprets <code>buf</code> as an array of 64-bit numbers and swaps byte order <em>in-place</em>.
|
||
Throws <a href="errors.html#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a> is not a multiple of 8.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 01 02 03 04 05 06 07 08></span>
|
||
|
||
buf1.swap64();
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1);
|
||
<span class="hljs-comment">// Prints: <Buffer 08 07 06 05 04 03 02 01></span>
|
||
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
|
||
|
||
buf2.swap64();
|
||
<span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
|
||
<h3><code>buf.toJSON()</code><span><a class="mark" href="#buffer_buf_tojson" id="buffer_buf_tojson">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.9.2</span>
|
||
</div>
|
||
<ul>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type"><Object></a></li>
|
||
</ul>
|
||
<p>Returns a JSON representation of <code>buf</code>. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify"><code>JSON.stringify()</code></a> implicitly calls
|
||
this function when stringifying a <code>Buffer</code> instance.</p>
|
||
<p><code>Buffer.from()</code> accepts objects in the format returned from this method.
|
||
In particular, <code>Buffer.from(buf.toJSON())</code> works like <code>Buffer.from(buf)</code>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>]);
|
||
<span class="hljs-keyword">const</span> json = <span class="hljs-built_in">JSON</span>.stringify(buf);
|
||
|
||
<span class="hljs-built_in">console</span>.log(json);
|
||
<span class="hljs-comment">// Prints: {"type":"Buffer","data":[1,2,3,4,5]}</span>
|
||
|
||
<span class="hljs-keyword">const</span> copy = <span class="hljs-built_in">JSON</span>.parse(json, <span class="hljs-function">(<span class="hljs-params">key, value</span>) =></span> {
|
||
<span class="hljs-keyword">return</span> value && value.type === <span class="hljs-string">'Buffer'</span> ?
|
||
Buffer.from(value) :
|
||
value;
|
||
});
|
||
|
||
<span class="hljs-built_in">console</span>.log(copy);
|
||
<span class="hljs-comment">// Prints: <Buffer 01 02 03 04 05></span></code></pre>
|
||
<h3><code>buf.toString([encoding[, start[, end]]])</code><span><a class="mark" href="#buffer_buf_tostring_encoding_start_end" id="buffer_buf_tostring_encoding_start_end">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.1.90</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> The character encoding to use. <strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The byte offset to start decoding at. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The byte offset to stop decoding at (not inclusive).
|
||
<strong>Default:</strong> <a href="#buffer_buf_length"><code>buf.length</code></a>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a></li>
|
||
</ul>
|
||
<p>Decodes <code>buf</code> to a string according to the specified character encoding in
|
||
<code>encoding</code>. <code>start</code> and <code>end</code> may be passed to decode only a subset of <code>buf</code>.</p>
|
||
<p>If <code>encoding</code> is <code>'utf8'</code> and a byte sequence in the input is not valid UTF-8,
|
||
then each invalid byte is replaced with the replacement character <code>U+FFFD</code>.</p>
|
||
<p>The maximum length of a string instance (in UTF-16 code units) is available
|
||
as <a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.MAX_STRING_LENGTH</code></a>.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i < <span class="hljs-number">26</span>; i++) {
|
||
<span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
|
||
buf1[i] = i + <span class="hljs-number">97</span>;
|
||
}
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'utf8'</span>));
|
||
<span class="hljs-comment">// Prints: abcdefghijklmnopqrstuvwxyz</span>
|
||
<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>));
|
||
<span class="hljs-comment">// Prints: abcde</span>
|
||
|
||
<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'tést'</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'hex'</span>));
|
||
<span class="hljs-comment">// Prints: 74c3a97374</span>
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
|
||
<span class="hljs-comment">// Prints: té</span>
|
||
<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-literal">undefined</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
|
||
<span class="hljs-comment">// Prints: té</span></code></pre>
|
||
<h3><code>buf.values()</code><span><a class="mark" href="#buffer_buf_values" id="buffer_buf_values">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v1.1.0</span>
|
||
</div>
|
||
<ul>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type"><Iterator></a></li>
|
||
</ul>
|
||
<p>Creates and returns an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">iterator</a> for <code>buf</code> values (bytes). This function is
|
||
called automatically when a <code>Buffer</code> is used in a <code>for..of</code> statement.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf.values()) {
|
||
<span class="hljs-built_in">console</span>.log(value);
|
||
}
|
||
<span class="hljs-comment">// Prints:</span>
|
||
<span class="hljs-comment">// 98</span>
|
||
<span class="hljs-comment">// 117</span>
|
||
<span class="hljs-comment">// 102</span>
|
||
<span class="hljs-comment">// 102</span>
|
||
<span class="hljs-comment">// 101</span>
|
||
<span class="hljs-comment">// 114</span>
|
||
|
||
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf) {
|
||
<span class="hljs-built_in">console</span>.log(value);
|
||
}
|
||
<span class="hljs-comment">// Prints:</span>
|
||
<span class="hljs-comment">// 98</span>
|
||
<span class="hljs-comment">// 117</span>
|
||
<span class="hljs-comment">// 102</span>
|
||
<span class="hljs-comment">// 102</span>
|
||
<span class="hljs-comment">// 101</span>
|
||
<span class="hljs-comment">// 114</span></code></pre>
|
||
<h3><code>buf.write(string[, offset[, length]][, encoding])</code><span><a class="mark" href="#buffer_buf_write_string_offset_length_encoding" id="buffer_buf_write_string_offset_length_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.1.90</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> String to write to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write <code>string</code>.
|
||
<strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Maximum number of bytes to write (written bytes will not
|
||
exceed <code>buf.length - offset</code>). <strong>Default:</strong> <code>buf.length - offset</code>.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> The character encoding of <code>string</code>. <strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>string</code> to <code>buf</code> at <code>offset</code> according to the character encoding in
|
||
<code>encoding</code>. The <code>length</code> parameter is the number of bytes to write. If <code>buf</code> did
|
||
not contain enough space to fit the entire string, only part of <code>string</code> will be
|
||
written. However, partially encoded characters will not be written.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">256</span>);
|
||
|
||
<span class="hljs-keyword">const</span> len = buf.write(<span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${len}</span> bytes: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, len)}</span>`</span>);
|
||
<span class="hljs-comment">// Prints: 12 bytes: ½ + ¼ = ¾</span>
|
||
|
||
<span class="hljs-keyword">const</span> buffer = Buffer.alloc(<span class="hljs-number">10</span>);
|
||
|
||
<span class="hljs-keyword">const</span> length = buffer.write(<span class="hljs-string">'abcd'</span>, <span class="hljs-number">8</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${length}</span> bytes: <span class="hljs-subst">${buffer.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">8</span>, <span class="hljs-number">10</span>)}</span>`</span>);
|
||
<span class="hljs-comment">// Prints: 2 bytes : ab</span></code></pre>
|
||
<h3><code>buf.writeBigInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64be_value_offset" id="buffer_buf_writebigint64be_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v12.0.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>
|
||
<p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
|
||
|
||
buf.writeBigInt64BE(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 01 02 03 04 05 06 07 08></span></code></pre>
|
||
<h3><code>buf.writeBigInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64le_value_offset" id="buffer_buf_writebigint64le_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v12.0.0, v10.20.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian.</p>
|
||
<p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
|
||
|
||
buf.writeBigInt64LE(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 08 07 06 05 04 03 02 01></span></code></pre>
|
||
<h3><code>buf.writeBigUInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64be_value_offset" id="buffer_buf_writebiguint64be_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeBigUint64BE()</code>.</p></td></tr>
|
||
<tr><td>v12.0.0, v10.20.0</td>
|
||
<td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
|
||
|
||
buf.writeBigUInt64BE(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer de ca fa fe ca ce fa de></span></code></pre>
|
||
<h3><code>buf.writeBigUInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64le_value_offset" id="buffer_buf_writebiguint64le_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeBigUint64LE()</code>.</p></td></tr>
|
||
<tr><td>v12.0.0</td>
|
||
<td><p><span>Added in: v12.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type"><bigint></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy: <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
|
||
|
||
buf.writeBigUInt64LE(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer de fa ce ca fe fa ca de></span></code></pre>
|
||
<h3><code>buf.writeDoubleBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublebe_value_offset" id="buffer_buf_writedoublebe_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
|
||
must be a JavaScript number. Behavior is undefined when <code>value</code> is anything
|
||
other than a JavaScript number.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
|
||
|
||
buf.writeDoubleBE(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 40 5e dd 2f 1a 9f be 77></span></code></pre>
|
||
<h3><code>buf.writeDoubleLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublele_value_offset" id="buffer_buf_writedoublele_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 8</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
|
||
must be a JavaScript number. Behavior is undefined when <code>value</code> is anything
|
||
other than a JavaScript number.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
|
||
|
||
buf.writeDoubleLE(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 77 be 9f 1a 2f dd 5e 40></span></code></pre>
|
||
<h3><code>buf.writeFloatBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatbe_value_offset" id="buffer_buf_writefloatbe_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. Behavior is
|
||
undefined when <code>value</code> is anything other than a JavaScript number.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeFloatBE(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 4f 4a fe bb></span>
|
||
</code></pre>
|
||
<h3><code>buf.writeFloatLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatle_value_offset" id="buffer_buf_writefloatle_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><number></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. Behavior is
|
||
undefined when <code>value</code> is anything other than a JavaScript number.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeFloatLE(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer bb fe 4a 4f></span></code></pre>
|
||
<h3><code>buf.writeInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint8_value_offset" id="buffer_buf_writeint8_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.0</td>
|
||
<td><p><span>Added in: v0.5.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 1</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a valid
|
||
signed 8-bit integer. Behavior is undefined when <code>value</code> is anything other than
|
||
a signed 8-bit integer.</p>
|
||
<p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
|
||
|
||
buf.writeInt8(<span class="hljs-number">2</span>, <span class="hljs-number">0</span>);
|
||
buf.writeInt8(<span class="hljs-number">-2</span>, <span class="hljs-number">1</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 02 fe></span></code></pre>
|
||
<h3><code>buf.writeInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16be_value_offset" id="buffer_buf_writeint16be_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
|
||
must be a valid signed 16-bit integer. Behavior is undefined when <code>value</code> is
|
||
anything other than a signed 16-bit integer.</p>
|
||
<p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
|
||
|
||
buf.writeInt16BE(<span class="hljs-number">0x0102</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 01 02></span></code></pre>
|
||
<h3><code>buf.writeInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16le_value_offset" id="buffer_buf_writeint16le_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
|
||
must be a valid signed 16-bit integer. Behavior is undefined when <code>value</code> is
|
||
anything other than a signed 16-bit integer.</p>
|
||
<p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
|
||
|
||
buf.writeInt16LE(<span class="hljs-number">0x0304</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 04 03></span></code></pre>
|
||
<h3><code>buf.writeInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32be_value_offset" id="buffer_buf_writeint32be_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
|
||
must be a valid signed 32-bit integer. Behavior is undefined when <code>value</code> is
|
||
anything other than a signed 32-bit integer.</p>
|
||
<p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeInt32BE(<span class="hljs-number">0x01020304</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 01 02 03 04></span></code></pre>
|
||
<h3><code>buf.writeInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32le_value_offset" id="buffer_buf_writeint32le_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
|
||
must be a valid signed 32-bit integer. Behavior is undefined when <code>value</code> is
|
||
anything other than a signed 32-bit integer.</p>
|
||
<p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeInt32LE(<span class="hljs-number">0x05060708</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 08 07 06 05></span></code></pre>
|
||
<h3><code>buf.writeIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintbe_value_offset_bytelength" id="buffer_buf_writeintbe_value_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to write. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
|
||
as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when
|
||
<code>value</code> is anything other than a signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
|
||
|
||
buf.writeIntBE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 12 34 56 78 90 ab></span>
|
||
</code></pre>
|
||
<h3><code>buf.writeIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintle_value_offset_bytelength" id="buffer_buf_writeintle_value_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.11.15</td>
|
||
<td><p><span>Added in: v0.11.15</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to write. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
|
||
as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
|
||
when <code>value</code> is anything other than a signed integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
|
||
|
||
buf.writeIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer ab 90 78 56 34 12></span></code></pre>
|
||
<h3><code>buf.writeUInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint8_value_offset" id="buffer_buf_writeuint8_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeUint8()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.0</td>
|
||
<td><p><span>Added in: v0.5.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 1</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a
|
||
valid unsigned 8-bit integer. Behavior is undefined when <code>value</code> is anything
|
||
other than an unsigned 8-bit integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeUInt8(<span class="hljs-number">0x3</span>, <span class="hljs-number">0</span>);
|
||
buf.writeUInt8(<span class="hljs-number">0x4</span>, <span class="hljs-number">1</span>);
|
||
buf.writeUInt8(<span class="hljs-number">0x23</span>, <span class="hljs-number">2</span>);
|
||
buf.writeUInt8(<span class="hljs-number">0x42</span>, <span class="hljs-number">3</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 03 04 23 42></span></code></pre>
|
||
<h3><code>buf.writeUInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16be_value_offset" id="buffer_buf_writeuint16be_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeUint16BE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
|
||
must be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code>
|
||
is anything other than an unsigned 16-bit integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeUInt16BE(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
|
||
buf.writeUInt16BE(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer de ad be ef></span></code></pre>
|
||
<h3><code>buf.writeUInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16le_value_offset" id="buffer_buf_writeuint16le_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeUint16LE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 2</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
|
||
must be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code> is
|
||
anything other than an unsigned 16-bit integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeUInt16LE(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
|
||
buf.writeUInt16LE(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer ad de ef be></span></code></pre>
|
||
<h3><code>buf.writeUInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32be_value_offset" id="buffer_buf_writeuint32be_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeUint32BE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
|
||
must be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code>
|
||
is anything other than an unsigned 32-bit integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeUInt32BE(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer fe ed fa ce></span></code></pre>
|
||
<h3><code>buf.writeUInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32le_value_offset" id="buffer_buf_writeuint32le_value_offset">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeUint32LE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - 4</code>. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
|
||
must be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code> is
|
||
anything other than an unsigned 32-bit integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
|
||
|
||
buf.writeUInt32LE(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer ce fa ed fe></span></code></pre>
|
||
<h3><code>buf.writeUIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintbe_value_offset_bytelength" id="buffer_buf_writeuintbe_value_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeUintBE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to write. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
|
||
as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined
|
||
when <code>value</code> is anything other than an unsigned integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
|
||
|
||
buf.writeUIntBE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer 12 34 56 78 90 ab></span></code></pre>
|
||
<h3><code>buf.writeUIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintle_value_offset_bytelength" id="buffer_buf_writeuintle_value_offset_bytelength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v12.19.0</td>
|
||
<td><p>This function is also available as <code>buf.writeUintLE()</code>.</p></td></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
|
||
<tr><td>v0.5.5</td>
|
||
<td><p><span>Added in: v0.5.5</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number to be written to <code>buf</code>.</li>
|
||
<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to skip before starting to write. Must
|
||
satisfy <code>0 <= offset <= buf.length - byteLength</code>.</li>
|
||
<li><code>byteLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to write. Must satisfy
|
||
<code>0 < byteLength <= 6</code>.</li>
|
||
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <code>offset</code> plus the number of bytes written.</li>
|
||
</ul>
|
||
<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
|
||
as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
|
||
when <code>value</code> is anything other than an unsigned integer.</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
|
||
|
||
buf.writeUIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
|
||
|
||
<span class="hljs-built_in">console</span>.log(buf);
|
||
<span class="hljs-comment">// Prints: <Buffer ab 90 78 56 34 12></span></code></pre>
|
||
<h3><code>new Buffer(array)</code><span><a class="mark" href="#buffer_new_buffer_array" id="buffer_new_buffer_array">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning when run from code outside the <code>node_modules</code> directory.</p></td></tr>
|
||
<tr><td>v7.2.1</td>
|
||
<td><p>Calling this constructor no longer emits a deprecation warning.</p></td></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning now.</p></td></tr>
|
||
<tr><td>v6.0.0</td>
|
||
<td><p><span>Deprecated since: v6.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a> instead.</div><p></p>
|
||
<ul>
|
||
<li><code>array</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer[]></a> An array of bytes to copy from.</li>
|
||
</ul>
|
||
<p>See <a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a>.</p>
|
||
<h3><code>new Buffer(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_new_buffer_arraybuffer_byteoffset_length" id="buffer_new_buffer_arraybuffer_byteoffset_length">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning when run from code outside the <code>node_modules</code> directory.</p></td></tr>
|
||
<tr><td>v7.2.1</td>
|
||
<td><p>Calling this constructor no longer emits a deprecation warning.</p></td></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning now.</p></td></tr>
|
||
<tr><td>v6.0.0</td>
|
||
<td><p>The <code>byteOffset</code> and <code>length</code> parameters are supported now.</p></td></tr>
|
||
<tr><td>v6.0.0</td>
|
||
<td><p><span>Deprecated since: v6.0.0</span></p></td></tr>
|
||
<tr><td>v3.0.0</td>
|
||
<td><p><span>Added in: v3.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use
|
||
<a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a>
|
||
instead.</div><p></p>
|
||
<ul>
|
||
<li><code>arrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type"><ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer" class="type"><SharedArrayBuffer></a> An <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>,
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> or the <code>.buffer</code> property of a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>.</li>
|
||
<li><code>byteOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Index of first byte to expose. <strong>Default:</strong> <code>0</code>.</li>
|
||
<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> Number of bytes to expose.
|
||
<strong>Default:</strong> <code>arrayBuffer.byteLength - byteOffset</code>.</li>
|
||
</ul>
|
||
<p>See
|
||
<a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a>.</p>
|
||
<h3><code>new Buffer(buffer)</code><span><a class="mark" href="#buffer_new_buffer_buffer" id="buffer_new_buffer_buffer">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning when run from code outside the <code>node_modules</code> directory.</p></td></tr>
|
||
<tr><td>v7.2.1</td>
|
||
<td><p>Calling this constructor no longer emits a deprecation warning.</p></td></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning now.</p></td></tr>
|
||
<tr><td>v6.0.0</td>
|
||
<td><p><span>Deprecated since: v6.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_static_method_buffer_from_buffer"><code>Buffer.from(buffer)</code></a> instead.</div><p></p>
|
||
<ul>
|
||
<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> An existing <code>Buffer</code> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> from
|
||
which to copy data.</li>
|
||
</ul>
|
||
<p>See <a href="#buffer_static_method_buffer_from_buffer"><code>Buffer.from(buffer)</code></a>.</p>
|
||
<h3><code>new Buffer(size)</code><span><a class="mark" href="#buffer_new_buffer_size" id="buffer_new_buffer_size">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning when run from code outside the <code>node_modules</code> directory.</p></td></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The <code>new Buffer(size)</code> will return zero-filled memory by default.</p></td></tr>
|
||
<tr><td>v7.2.1</td>
|
||
<td><p>Calling this constructor no longer emits a deprecation warning.</p></td></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning now.</p></td></tr>
|
||
<tr><td>v6.0.0</td>
|
||
<td><p><span>Deprecated since: v6.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> instead (also see
|
||
<a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>).</div><p></p>
|
||
<ul>
|
||
<li><code>size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The desired length of the new <code>Buffer</code>.</li>
|
||
</ul>
|
||
<p>See <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> and <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>. This variant of the
|
||
constructor is equivalent to <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a>.</p>
|
||
<h3><code>new Buffer(string[, encoding])</code><span><a class="mark" href="#buffer_new_buffer_string_encoding" id="buffer_new_buffer_string_encoding">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v10.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning when run from code outside the <code>node_modules</code> directory.</p></td></tr>
|
||
<tr><td>v7.2.1</td>
|
||
<td><p>Calling this constructor no longer emits a deprecation warning.</p></td></tr>
|
||
<tr><td>v7.0.0</td>
|
||
<td><p>Calling this constructor emits a deprecation warning now.</p></td></tr>
|
||
<tr><td>v6.0.0</td>
|
||
<td><p><span>Deprecated since: v6.0.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated:
|
||
Use <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a> instead.</div><p></p>
|
||
<ul>
|
||
<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> String to encode.</li>
|
||
<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> The encoding of <code>string</code>. <strong>Default:</strong> <code>'utf8'</code>.</li>
|
||
</ul>
|
||
<p>See <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a>.</p>
|
||
<h2><code>buffer</code> module APIs<span><a class="mark" href="#buffer_buffer_module_apis" id="buffer_buffer_module_apis">#</a></span></h2>
|
||
<p>While, the <code>Buffer</code> object is available as a global, there are additional
|
||
<code>Buffer</code>-related APIs that are available only via the <code>buffer</code> module
|
||
accessed using <code>require('buffer')</code>.</p>
|
||
<h3><code>buffer.INSPECT_MAX_BYTES</code><span><a class="mark" href="#buffer_buffer_inspect_max_bytes" id="buffer_buffer_inspect_max_bytes">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v0.5.4</span>
|
||
</div>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> <strong>Default:</strong> <code>50</code></li>
|
||
</ul>
|
||
<p>Returns the maximum number of bytes that will be returned when
|
||
<code>buf.inspect()</code> is called. This can be overridden by user modules. See
|
||
<a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a> for more details on <code>buf.inspect()</code> behavior.</p>
|
||
<h3><code>buffer.kMaxLength</code><span><a class="mark" href="#buffer_buffer_kmaxlength" id="buffer_buffer_kmaxlength">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v3.0.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The largest size allowed for a single <code>Buffer</code> instance.</li>
|
||
</ul>
|
||
<p>An alias for <a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a>.</p>
|
||
<h3><code>buffer.transcode(source, fromEnc, toEnc)</code><span><a class="mark" href="#buffer_buffer_transcode_source_fromenc_toenc" id="buffer_buffer_transcode_source_fromenc_toenc">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<details class="changelog"><summary>History</summary>
|
||
<table>
|
||
<tbody><tr><th>Version</th><th>Changes</th></tr>
|
||
<tr><td>v8.0.0</td>
|
||
<td><p>The <code>source</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
|
||
<tr><td>v7.1.0</td>
|
||
<td><p><span>Added in: v7.1.0</span></p></td></tr>
|
||
</tbody></table>
|
||
</details>
|
||
</div>
|
||
<ul>
|
||
<li><code>source</code> <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type"><Uint8Array></a> A <code>Buffer</code> or <code>Uint8Array</code> instance.</li>
|
||
<li><code>fromEnc</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> The current encoding.</li>
|
||
<li><code>toEnc</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type"><string></a> To target encoding.</li>
|
||
<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type"><Buffer></a></li>
|
||
</ul>
|
||
<p>Re-encodes the given <code>Buffer</code> or <code>Uint8Array</code> instance from one character
|
||
encoding to another. Returns a new <code>Buffer</code> instance.</p>
|
||
<p>Throws if the <code>fromEnc</code> or <code>toEnc</code> specify invalid character encodings or if
|
||
conversion from <code>fromEnc</code> to <code>toEnc</code> is not permitted.</p>
|
||
<p>Encodings supported by <code>buffer.transcode()</code> are: <code>'ascii'</code>, <code>'utf8'</code>,
|
||
<code>'utf16le'</code>, <code>'ucs2'</code>, <code>'latin1'</code>, and <code>'binary'</code>.</p>
|
||
<p>The transcoding process will use substitution characters if a given byte
|
||
sequence cannot be adequately represented in the target encoding. For instance:</p>
|
||
<pre><code class="language-js"><span class="hljs-keyword">const</span> buffer = <span class="hljs-built_in">require</span>(<span class="hljs-string">'buffer'</span>);
|
||
|
||
<span class="hljs-keyword">const</span> newBuf = buffer.transcode(Buffer.from(<span class="hljs-string">'€'</span>), <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'ascii'</span>);
|
||
<span class="hljs-built_in">console</span>.log(newBuf.toString(<span class="hljs-string">'ascii'</span>));
|
||
<span class="hljs-comment">// Prints: '?'</span></code></pre>
|
||
<p>Because the Euro (<code>€</code>) sign is not representable in US-ASCII, it is replaced
|
||
with <code>?</code> in the transcoded <code>Buffer</code>.</p>
|
||
<h3>Class: <code>SlowBuffer</code><span><a class="mark" href="#buffer_class_slowbuffer" id="buffer_class_slowbuffer">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Deprecated since: v6.0.0</span>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a> instead.</div><p></p>
|
||
<p>See <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>. This was never a class in the sense that
|
||
the constructor always returned a <code>Buffer</code> instance, rather than a <code>SlowBuffer</code>
|
||
instance.</p>
|
||
<h4><code>new SlowBuffer(size)</code><span><a class="mark" href="#buffer_new_slowbuffer_size" id="buffer_new_slowbuffer_size">#</a></span></h4>
|
||
<div class="api_metadata">
|
||
<span>Deprecated since: v6.0.0</span>
|
||
</div>
|
||
<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a> instead.</div><p></p>
|
||
<ul>
|
||
<li><code>size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The desired length of the new <code>SlowBuffer</code>.</li>
|
||
</ul>
|
||
<p>See <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>.</p>
|
||
<h3>Buffer constants<span><a class="mark" href="#buffer_buffer_constants" id="buffer_buffer_constants">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v8.2.0</span>
|
||
</div>
|
||
<h4><code>buffer.constants.MAX_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_length" id="buffer_buffer_constants_max_length">#</a></span></h4>
|
||
<div class="api_metadata">
|
||
<span>Added in: v8.2.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The largest size allowed for a single <code>Buffer</code> instance.</li>
|
||
</ul>
|
||
<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).
|
||
On 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).</p>
|
||
<p>This value is also available as <a href="#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a>.</p>
|
||
<h4><code>buffer.constants.MAX_STRING_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_string_length" id="buffer_buffer_constants_max_string_length">#</a></span></h4>
|
||
<div class="api_metadata">
|
||
<span>Added in: v8.2.0</span>
|
||
</div>
|
||
<ul>
|
||
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type"><integer></a> The largest length allowed for a single <code>string</code> instance.</li>
|
||
</ul>
|
||
<p>Represents the largest <code>length</code> that a <code>string</code> primitive can have, counted
|
||
in UTF-16 code units.</p>
|
||
<p>This value may depend on the JS engine that is being used.</p>
|
||
<h2><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code><span><a class="mark" href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe" id="buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe">#</a></span></h2>
|
||
<p>In versions of Node.js prior to 6.0.0, <code>Buffer</code> instances were created using the
|
||
<code>Buffer</code> constructor function, which allocates the returned <code>Buffer</code>
|
||
differently based on what arguments are provided:</p>
|
||
<ul>
|
||
<li>Passing a number as the first argument to <code>Buffer()</code> (e.g. <code>new Buffer(10)</code>)
|
||
allocates a new <code>Buffer</code> object of the specified size. Prior to Node.js 8.0.0,
|
||
the memory allocated for such <code>Buffer</code> instances is <em>not</em> initialized and
|
||
<em>can contain sensitive data</em>. Such <code>Buffer</code> instances <em>must</em> be subsequently
|
||
initialized by using either <a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(0)</code></a> or by writing to the
|
||
entire <code>Buffer</code> before reading data from the <code>Buffer</code>.
|
||
While this behavior is <em>intentional</em> to improve performance,
|
||
development experience has demonstrated that a more explicit distinction is
|
||
required between creating a fast-but-uninitialized <code>Buffer</code> versus creating a
|
||
slower-but-safer <code>Buffer</code>. Since Node.js 8.0.0, <code>Buffer(num)</code> and <code>new Buffer(num)</code> return a <code>Buffer</code> with initialized memory.</li>
|
||
<li>Passing a string, array, or <code>Buffer</code> as the first argument copies the
|
||
passed object's data into the <code>Buffer</code>.</li>
|
||
<li>Passing an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> or a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> returns a <code>Buffer</code>
|
||
that shares allocated memory with the given array buffer.</li>
|
||
</ul>
|
||
<p>Because the behavior of <code>new Buffer()</code> is different depending on the type of the
|
||
first argument, security and reliability issues can be inadvertently introduced
|
||
into applications when argument validation or <code>Buffer</code> initialization is not
|
||
performed.</p>
|
||
<p>For example, if an attacker can cause an application to receive a number where
|
||
a string is expected, the application may call <code>new Buffer(100)</code>
|
||
instead of <code>new Buffer("100")</code>, leading it to allocate a 100 byte buffer instead
|
||
of allocating a 3 byte buffer with content <code>"100"</code>. This is commonly possible
|
||
using JSON API calls. Since JSON distinguishes between numeric and string types,
|
||
it allows injection of numbers where a naively written application that does not
|
||
validate its input sufficiently might expect to always receive a string.
|
||
Before Node.js 8.0.0, the 100 byte buffer might contain
|
||
arbitrary pre-existing in-memory data, so may be used to expose in-memory
|
||
secrets to a remote attacker. Since Node.js 8.0.0, exposure of memory cannot
|
||
occur because the data is zero-filled. However, other attacks are still
|
||
possible, such as causing very large buffers to be allocated by the server,
|
||
leading to performance degradation or crashing on memory exhaustion.</p>
|
||
<p>To make the creation of <code>Buffer</code> instances more reliable and less error-prone,
|
||
the various forms of the <code>new Buffer()</code> constructor have been <strong>deprecated</strong>
|
||
and replaced by separate <code>Buffer.from()</code>, <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a>, and
|
||
<a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> methods.</p>
|
||
<p><em>Developers should migrate all existing uses of the <code>new Buffer()</code> constructors
|
||
to one of these new APIs.</em></p>
|
||
<ul>
|
||
<li><a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a> returns a new <code>Buffer</code> that <em>contains a copy</em> of the
|
||
provided octets.</li>
|
||
<li><a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a>
|
||
returns a new <code>Buffer</code> that <em>shares the same allocated memory</em> as the given
|
||
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>.</li>
|
||
<li><a href="#buffer_static_method_buffer_from_buffer"><code>Buffer.from(buffer)</code></a> returns a new <code>Buffer</code> that <em>contains a copy</em> of the
|
||
contents of the given <code>Buffer</code>.</li>
|
||
<li><a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a> returns a new
|
||
<code>Buffer</code> that <em>contains a copy</em> of the provided string.</li>
|
||
<li><a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc(size[, fill[, encoding]])</code></a> returns a new
|
||
initialized <code>Buffer</code> of the specified size. This method is slower than
|
||
<a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe(size)</code></a> but guarantees that newly
|
||
created <code>Buffer</code> instances never contain old data that is potentially
|
||
sensitive. A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</li>
|
||
<li><a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe(size)</code></a> and
|
||
<a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow(size)</code></a> each return a
|
||
new uninitialized <code>Buffer</code> of the specified <code>size</code>. Because the <code>Buffer</code> is
|
||
uninitialized, the allocated segment of memory might contain old data that is
|
||
potentially sensitive.</li>
|
||
</ul>
|
||
<p><code>Buffer</code> instances returned by <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> and
|
||
<a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a> <em>may</em> be allocated off a shared internal memory pool
|
||
if <code>size</code> is less than or equal to half <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a>. Instances
|
||
returned by <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a> <em>never</em> use the shared internal
|
||
memory pool.</p>
|
||
<h3>The <code>--zero-fill-buffers</code> command line option<span><a class="mark" href="#buffer_the_zero_fill_buffers_command_line_option" id="buffer_the_zero_fill_buffers_command_line_option">#</a></span></h3>
|
||
<div class="api_metadata">
|
||
<span>Added in: v5.10.0</span>
|
||
</div>
|
||
<p>Node.js can be started using the <code>--zero-fill-buffers</code> command line option to
|
||
cause all newly-allocated <code>Buffer</code> instances to be zero-filled upon creation by
|
||
default. Without the option, buffers created with <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>,
|
||
<a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>, and <code>new SlowBuffer(size)</code> are not zero-filled.
|
||
Use of this flag can have a measurable negative impact on performance. Use the
|
||
<code>--zero-fill-buffers</code> option only when necessary to enforce that newly allocated
|
||
<code>Buffer</code> instances cannot contain old data that is potentially sensitive.</p>
|
||
<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --zero-fill-buffers</span>
|
||
<span class="hljs-meta">></span><span class="bash"> Buffer.allocUnsafe(5);</span>
|
||
<Buffer 00 00 00 00 00></code></pre>
|
||
<h3>What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?<span><a class="mark" href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe" id="buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">#</a></span></h3>
|
||
<p>When calling <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> and <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>, the
|
||
segment of allocated memory is <em>uninitialized</em> (it is not zeroed-out). While
|
||
this design makes the allocation of memory quite fast, the allocated segment of
|
||
memory might contain old data that is potentially sensitive. Using a <code>Buffer</code>
|
||
created by <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> without <em>completely</em> overwriting the
|
||
memory can allow this old data to be leaked when the <code>Buffer</code> memory is read.</p>
|
||
<p>While there are clear performance advantages to using
|
||
<a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>, extra care <em>must</em> be taken in order to avoid
|
||
introducing security vulnerabilities into an application.</p>
|
||
<!-- API END -->
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</body>
|
||
</html>
|