12

我想以大端格式将 64 位（8 字节）大整数存储到 nodejs 缓冲区对象。

关于这个任务的问题是 nodejs 缓冲区只支持写入 32 位整数作为最大值（使用 buf.write32UInt32BE(value, offset)）。所以我想，为什么我们不能只拆分 64 位整数呢？

var buf = new Buffer(8);

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

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

buf.write32UInt32BE(0xff, 4); // right the first part of the int
console.log(buf); // outputs <Buffer 00 00 00 00 00 00 00 ff>

buf.write32UInt32BE(0xff, 0); // right the second part of the int
console.log(buf); // outputs <Buffer 00 00 00 ff 00 00 00 ff>

var bufInt = buf.read32UInt32BE(0) * buf.read32UInt32BE(4);
console.log(bufInt); // outputs 65025

如您所见，这几乎可以正常工作。问题只是拆分 64 位整数并在读取它时找到丢失的 510。有人介意展示这两个问题的解决方案吗？

4

6 回答 6

11

我认为您正在寻找的是：

var bufInt = (buf.readUInt32BE(0) << 8) + buf.readUInt32BE(4);

将第一个数字移动 8 位并添加（而不是相乘），然后返回65535

编辑

另一种写法是：

var buf = new Buffer(8);
buf.fill(0);

var i = 0xCDEF; // 52719 in decimal

buf.writeUInt32BE(i >> 8, 0); //write the high order bits (shifted over)
buf.writeUInt32BE(i & 0x00ff, 4); //write the low order bits

console.log(buf); //displays: <Buffer 00 00 00 cd 00 00 00 ef>

var bufInt = (buf.readUInt32BE(0) << 8) + buf.readUInt32BE(4);
console.log(bufInt); //displays: 52719
于 2013-02-06T14:12:35.073 回答
2

我很困惑，因为您的示例值0xFFFF只有 16 位，而不是 64 位。

请记住，JSnumber类型被指定为 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);
于 2013-02-06T17:00:23.340 回答
2

读取和写入 UINT 数，最高可达Number.MAX_SAFE_INTEGER.

这仅适用于 node.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;
}
于 2018-06-29T09:06:06.687 回答
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);
于 2014-02-23T06:21:07.130 回答
0

JavaScript/EcmaScript 中的按位运算将强制数字（或任何值）转换为 32 位整数。

如果您需要一定的精度，或者处理大于 32 位值的缓冲区，您确实需要使用bignum来获取更大的值。

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_INTEGERwhich is Math.pow(2,53)-1。如果您需要使用更大的数字，则应将它们作为 bignum 字符串访问...如果您可以保持在 JS 中的 Integers 范围内，则可以保留它们并按上述方式进行转换。

于 2015-04-14T23:41:31.563 回答
0

读取/写入 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

于 2016-03-02T09:36:48.697 回答