Buffer in Node.js: Writing Data Methods

1. Writing BigUInt64

• buf.writeBigUInt64BE(value, offset): Writes an unsigned 64-bit bigint in big-endian format.
• buf.writeBigUInt64LE(value, offset): Writes an unsigned 64-bit bigint in little-endian format.

const buf = Buffer.allocUnsafe(8);
buf.writeBigUInt64BE(0xdecafafecacefaden, 0);
console.log(buf); // 

2. Writing Double and Float

• buf.writeDoubleBE(value, offset): Writes a 64-bit floating-point number in big-endian format.
• buf.writeDoubleLE(value, offset): Writes a 64-bit floating-point number in little-endian format.
• buf.writeFloatBE(value, offset): Writes a 32-bit floating-point number in big-endian format.
• buf.writeFloatLE(value, offset): Writes a 32-bit floating-point number in little-endian format.

const buf = Buffer.allocUnsafe(8);
buf.writeDoubleBE(123.456, 0);
console.log(buf);

3. Writing Small Integers

• buf.writeInt8(value, offset): Writes a signed 8-bit integer.
• buf.writeUInt8(value, offset): Writes an unsigned 8-bit integer.

const buf = Buffer.allocUnsafe(2);
buf.writeInt8(2, 0);
buf.writeInt8(-2, 1);
console.log(buf); // 

4. Writing Int16 and UInt16

• buf.writeInt16BE(value, offset): Writes a signed 16-bit integer in big-endian format.
• buf.writeInt16LE(value, offset): Writes a signed 16-bit integer in little-endian format.
• buf.writeUInt16BE(value, offset): Writes an unsigned 16-bit integer in big-endian format.
• buf.writeUInt16LE(value, offset): Writes an unsigned 16-bit integer in little-endian format.

5. Writing Int32 and UInt32

• buf.writeInt32BE(value, offset): Writes a signed 32-bit integer in big-endian format.
• buf.writeInt32LE(value, offset): Writes a signed 32-bit integer in little-endian format.
• buf.writeUInt32BE(value, offset): Writes an unsigned 32-bit integer in big-endian format.
• buf.writeUInt32LE(value, offset): Writes an unsigned 32-bit integer in little-endian format.

6. Writing IntBE / IntLE and UIntBE / UIntLE

Writes integers of variable length (1–6 bytes) in big-endian or little-endian format.

const buf = Buffer.allocUnsafe(6);
buf.writeIntBE(0x1234567890ab, 0, 6);
console.log(buf); // 

7. Writing Strings

buf.write(string[, offset[, length]][, encoding]): Writes a string into the Buffer using the specified encoding (default: UTF-8).

const buf = Buffer.alloc(256);
const len = buf.write('½ + ¼ = ¾', 0);
console.log(`${len} bytes: ${buf.toString('utf8',0,len)}`);

Conclusion

The Buffer write methods provide precise control over storing binary data in different formats. With support for signed and unsigned integers, floating-point numbers, big integers, and strings, these methods are essential for low-level data processing in Node.js applications.

1. Handling Function Arguments

Addons often expose functions to JavaScript. These functions must validate the number and type of arguments before performing operations.

// addon.cc
void Add(const FunctionCallbackInfo& args) {
  Isolate* isolate = args.GetIsolate();

  if (args.Length() < 2) {
    isolate->ThrowException(Exception::TypeError(
        String::NewFromUtf8(isolate,"Wrong number of arguments").ToLocalChecked()));
    return;
  }

  if (!args[0]->IsNumber() || !args[1]->IsNumber()) {
    isolate->ThrowException(Exception::TypeError(
        String::NewFromUtf8(isolate,"Wrong arguments").ToLocalChecked()));
    return;
  }

  double value = args[0].As()->Value() + args[1].As()->Value();
  Local num = Number::New(isolate, value);
  args.GetReturnValue().Set(num);
}

This function adds two numbers and returns the result to JavaScript.

2. Executing Callbacks

Addons can accept JavaScript functions as arguments and invoke them from C++.

// addon.cc
void RunCallback(const FunctionCallbackInfo& args) {
  Isolate* isolate = args.GetIsolate();
  Local context = isolate->GetCurrentContext();
  Local cb = Local::Cast(args[0]);
  const unsigned argc = 1;
  Local argv[argc] = {
      String::NewFromUtf8(isolate,"hello world").ToLocalChecked() };
  cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();
}

In this example, the callback is invoked synchronously and prints "hello world".

3. Object Factory

Addons can create and return new objects from C++ functions. These objects can contain properties set from input arguments.

// addon.cc
void CreateObject(const FunctionCallbackInfo& args) {
  Isolate* isolate = args.GetIsolate();
  Local context = isolate->GetCurrentContext();

  Local