nodejs записывает 64-битное целое число без знака в буфер

чтение и записи UINT номера до Number.MAX_SAFE_INTEGER.

это работает в узле.только js, не переносится на стороне браузера.

function uintToBase62(n) {
  if (n < 0) throw 'unsupported negative integer';

  let uintBuffer;
  if (n < 0x7FFFFFFF) {
    uintBuffer = new Buffer(4);
    uintBuffer.writeUInt32BE(n, 0);
  } else {
    // `~~` double bitwise operator
    // The most practical way of utilizing the power of this operator is to use it as a replacement
    // for Math.floor() function as double bitwise NOT performs the same operation a lot quicker.
    // You can use it, to convert any floating point number to a integer without performance overkill
    // that comes with Math.floor(). Additionally, when you care about minification of your code,
    // you end up using 2 characters (2 tildes) instead of 12.
    // http://rocha.la/JavaScript-bitwise-operators-in-practice
    const big = ~~(n / 0x0100000000);
    const low = (n % 0x0100000000);
    uintBuffer = new Buffer(8);
    uintBuffer.writeUInt32BE(big, 0);
    uintBuffer.writeUInt32BE(low, 4);
  }

  return uintBuffer.toString('hex');
}

преобразовать его

function uintFromBase62(uintBuffer) {
  const n = parseInt(uintBuffer.toString('hex'), 16);
  return n;
}

Я смущен, потому что ваш пример значения 0xFFFF только 16-разрядный, не 64-разрядный.

имейте в виду, что JS number тип указан как значение с плавающей запятой IEEE754, поэтому не гарантируется возможность хранения 64-разрядного значения без знака. Если вы хотите реальную 64-битную целочисленную поддержку, вам нужно использовать модуль для ее предоставления, например bignum. Ридми для этого есть примеры чтения и записи значений в буфер.

значения с плавающей точкой могут только представлять значения до 2^53 - 1 без потери точности. Вы можете видеть, что в этом примере, используя стандартные номера JS:

var b = new Buffer([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
var firstHalf = b.readUInt32BE(0); // 4294967295
var secondHalf = b.readUInt32BE(4); // 4294967295

var val = firstHalf * 0x100000000 + secondHalf; // 18446744073709552000

в результате 18446744073709552000 когда правильное значение 18446744073709551615.

var bignum = require('bignum');

var b = new Buffer([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
var val = bignum.fromBuffer(b);

в результате BigNum объект со значением 18446744073709551615.

кроме того, чтобы уточнить ваш пример кода, значение, которое вы используете, только 16-разрядное, и вы пытаетесь работать с ним, используя 32-разрядные функции. Вы можете просто сделать это:

var buf = new Buffer(2);

buf.fill(0) // clear all bytes of the buffer
console.log(buf); // outputs <Buffer 00 00>

var int = 0xffff; // as decimal: 65535

// Write it with a standard 16-bit function calls.
buf.writeUInt16BE(int);

// OR write it with 2 8-bit function calls.
buf.writeUInt8(int & 0xff, 0); // right the first part of the int
buf.writeUInt8((int >> 8) & 0xFF, 1); // right the second part of the int
console.log(buf); // outputs <Buffer ff ff>

// Read it as a 16-bit value.
var bufInt = buf.readUInt16BE(0);
console.log(bufInt);

// OR read it as two 8-bit values.
var bufInt = (buf.readUInt8(1) << 8) + buf.readUInt8(0);

// sending time
var sending_time = new Date().getTime();
buffer.writeInt32LE(parseInt(sending_time & 0xffffffff, 10), 16);
buffer.writeInt32LE(parseInt(sending_time / 0xffffffff, 10), 20);

побитовые операции в JavaScript / EcmaScript заставят число (или любое значение на самом деле) в 32-разрядное целое число.

вы действительно нужно использовать bignum для больших значений, если вам нужна определенная точность или работа с буферами с более чем 32-разрядными значениями.

var bignum = require('bignum');

//max safe integer to big number
var num = bignum(Number.MAX_SAFE_INTEGER.toString());
var buf = num.toBuffer({endian:'big',size:8 /*8-byte / 64-bit*/});

console.log(buf); // 

В приведенном выше примере используется Number.MAX_SAFE_INTEGER что это Math.pow(2,53)-1. Если вам нужно использовать большие числа, они должны быть доступны как bignum строк... если вы можете оставаться в пределах диапазона чисел в JS, вы можете сохранить их и преобразовать, как указано выше.

чтение / запись 64-битных значений:

const int64 = Date.now()   // 1456909977176 (00 00 01 53 36 9a 06 58)
const b = new Buffer(8)
const MAX_UINT32 = 0xFFFFFFFF

// write
const big = ~~(int64 / MAX_UINT32)
const low = (int64 % MAX_UINT32) - big

b.writeUInt32BE(big, 0)  // 00 00 01 53 00 00 00 00
b.writeUInt32BE(low, 4)  // 00 00 01 53 36 9a 06 58

// read
var time = parseInt(b.toString('hex'), 16)
time == int64 // true

Я использую этот код без каких-либо специальных модулей.

обновление

работает только для чисел <= Number.MAX_SAFE_INTEGER