Shulou(Shulou.com)06/02 Report--

Node.js Buffer module method and example analysis, for this problem, this article details the corresponding analysis and solution, hoping to help more small partners who want to solve this problem to find a simpler and easier way.

Binary streams are collections of large amounts of binary data. Because binary streams are usually quite large in size, binary streams are generally not shipped together, but are cut into small pieces before transportation and sent one by one.

When the data processing unit temporarily stops receiving other data streams, the remaining data is retained in the buffer until the data processing unit is ready to receive more data.

Node.js servers generally need to read and write in the file system, and files are actually binary streams at the storage level. In addition, Node.js can be used with TCP streams to provide reliable end-to-end byte stream guarantees over unreliable Internet networks.

The data stream sent to the receiver is buffered until the receiver is ready to receive more data to process. This is what Node.js does with the temporary data part, managing and storing binary data outside of the V8 engine.

Let's dive into the various ways buffers are used, learn more about them, and learn how to use them in Node.js programs.

Methods of Node.js Buffer

The biggest advantage of the Node.js buffer module is that it is built into Node.js, so we can use it wherever we want.

Let's take a look at some of the important ways Node.js buffers modules.

Buffer.alloc()

This method creates a new buffer, but the size allocated is not fixed. When we call this method, we can assign our own size (in bytes).

const buffer f = Buffer.alloc(6) //This creates a 6-byte buffer console.log(buffer f) //

Buffer.byteLength()

If we want to get the length of the buffer, we simply call Buffer.byteLength().

var bufff = Buffer.alloc(10)var buffLen = Buffer.byteLength(bufff) //check buffer length console.log (buffLen) // 10

Buffer.compare()

By using Buffer.compare () we can compare two buffers, and the return value of this method is one of-1, 0, 1.

buf.compare(otherBuffer); this call returns a number-1, 0, 1, corresponding to buffer f before, after, or the same as otherBuffer.

var bufff1 = Buffer.from('Harsh')var bufff2 = Buffer.from('Harsg')var a = Buffer.compare (bufff1, bufff2)console.log(a) //This prints 0 var bufff1 = Buffer.from('a')var bufff2 = Buffer.from('b')var a = Buffer.compare (bufff1, bufff2)console.log(a) /This prints-1 var bufff1 = Buffer.from('b')var bufff2 = Buffer. from('a')var a = Buffer.compare (bufff1, bufff2)console.log(a) //This prints 1

Buffer.concat()

As the name suggests, we can use this function to connect two buffers. Of course, just like strings, we can concatenate more than two buffers.

var buffer1 = Buffer.from('x')var buffer2 = Buffer.from('y')var buffer3 = Buffer.from('z')var arr = [buffer1, buffer2, buffer3] console.log(arr)/* buffer, ! concat [ , , ] *//connect two buffers via Buffer.concat method var buffer = Buffer.concat(arr) console.log(buffer)// concat successful

Buffer.entries()

Buffer.entries() creates and returns an iterator of the form [index, byte] from the contents of this buffer.

var buf = Buffer.from('xyz') for (a of buf.entries()) { console.log(a) /* This outputs an array of bytes with buffer locations and contents to the console [ 0, 120 ][ 1, 121 ][ 2, 122 ] */}

Buffer.fill()

We can insert or fill data into a buffer using Buffer.fill(). See below for more information.

const b = Buffer.alloc(10).fill('a') console.log(b.toString())// aaaaaaaaaa

Buffer.includes()

Like a string, it confirms whether the buffer has that value. We can do this using the Buffer.includes() method, given that the method returns a Boolean value, either true or false, depending on the search.

const buf = Buffer.from('this is a buffer')console.log(buf.includes('this'))// true console.log(buf.includes(Buffer.from('a buffer example')))// false

Buffer.isEncoding()

We probably know that binary files must be encoded, so what if we want to check whether the data type supports character encoding? We can use Buffer.isEncoding() method to confirm. If supported, it returns true.

console.log(Buffer.isEncoding('hex'))// true console.log(Buffer.isEncoding('utf-8'))// true console.log(Buffer.isEncoding('utf/8'))// false console.log(Buffer.isEncoding('hey'))// false

Buffer.slice()

buf.slice() will be used to create a new buffer using the selected elements of the buffer--When a buffer is cut, a new buffer is created with a list of items to be found in the new buffer slice.

var a = Buffer.from('uvwxyz');var b = a.slice(2, 5); console.log(b.toString());// wxy

Buffer.swapX()

Buffer.swapX() is used to swap byte order of buffers. Use Buffer.swapX()(where X can be 16, 32, 64) to swap the byte order of 16-bit, 32-bit, and 64-bit buffer objects.

const bufff1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])console.log(bufff1)///swap 16-bit endian bufff1.swap16 ()console.log(bufff1)///swap 32-bit endian bufff1.swap32 ()console. log(bufff1)///swap 64-bit endian bufff1.swap64 ()console.log(bufff1)//

Buffer.json()

It helps us create JSON objects from buffers, and this method will return JSON buffer objects,

const buffer f = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); console.log(buffer.toJSON());// {"type":"Buffer", data:[1, 2, 3, 4, 5, 6, 7, 8]} About Node.js Buffer module methods and sample analysis questions to share here, I hope the above content can be of some help to everyone, if you still have a lot of doubts, you can pay attention to the industry information channel to learn more related knowledge.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.