JS利用ES6和ES5分别实现长整数和字节数组互转

/**
 * 将64位长整数转换为8字节数组（支持符号和字节序）
 * @param {BigInt} long - 输入的长整数
 * @param {Object} [options] - 配置项
 * @param {boolean} [options.signed=false] - 是否生成有符号字节
 * @param {boolean} [options.littleEndian=false] - 是否小端序
 * @returns {Uint8Array|Int8Array} 字节数组
 */
function longToBytes(long, { signed = false, littleEndian = false } = {}) {
  const buffer = new ArrayBuffer(8);
  const view = new DataView(buffer);
  
  // 写入BigInt
  littleEndian ? 
    view.setBigInt64(0, long, true) : 
    view.setBigUint64(0, long);
  
  // 读取字节
  const bytes = signed ? 
    new Int8Array(buffer) : 
    new Uint8Array(buffer);
  
  return bytes;
}

/**
 * 将字节数组转换为长整数
 * @param {Uint8Array|Int8Array} bytes - 输入的8字节数组
 * @param {Object} [options] - 配置项 
 * @param {boolean} [options.signed=false] - 是否解析为有符号数
 * @param {boolean} [options.littleEndian=false] - 是否小端序
 * @returns {BigInt} 解析后的长整数
 */
function bytesToLong(bytes, { signed = false, littleEndian = false } = {}) {
  const buffer = bytes.buffer;
  const view = new DataView(buffer);
  
  return littleEndian ?
    view.getBigInt64(0, true) :
    (signed ? 
      view.getBigInt64(0) : 
      view.getBigUint64(0));
}

// --------------- 测试用例 ---------------
const timestamp = 1743656342584n;

// 转换为有符号字节数组（模拟 Java 的 byte[]）
const bytesSigned = longToBytes(timestamp, true); // 默认大端序
console.log("有符号字节数组:", bytesSigned); 
// 输出: Int8Array [0, 0, 1, -107, -6, 4, 84, 56] （与 Java 一致）// 还原长整数
const restored = bytesToLong(bytesSigned, true);


console.log("还原结果:", restored.toString()); // 1743656342584n

/**
 * 将长整数转换为 8 字节数组（ES5 语法，兼容有符号字节）
 * @param {number} long - 长整数（需在 2^53 范围内确保精度）
 * @param {boolean} [signed] - 是否输出有符号字节（默认 false）
 * @param {boolean} [littleEndian] - 是否小端序（默认 false）
 * @returns {Int8Array|Uint8Array} 8 字节数组
 */
function longToBytes(long, signed, littleEndian) {
  signed = typeof signed !== 'undefined' ? signed : false;
  littleEndian = typeof littleEndian !== 'undefined' ? littleEndian : false;

  // 转换为 16 进制字符串，补零至 16 字符
  var hex = ('0000000000000000' + long.toString(16)).slice(-16);
  var bytes = signed ? new Int8Array(8) : new Uint8Array(8);

  for (var i = 0; i < 8; i++) {
    // 计算字节位置
    var pos = littleEndian ? (7 - i) : i;
    var byteStr = hex.substr(pos * 2, 2);
    var byteValue = parseInt(byteStr, 16);

    // 处理有符号字节
    if (signed && byteValue > 127) {
      byteValue -= 256;
    }
    bytes[i] = byteValue;
  }

  return bytes;
}

/**
 * 将字节数组转换为长整数（ES5 语法，兼容有符号字节）
 * @param {Int8Array|Uint8Array} bytes - 8 字节数组
 * @param {boolean} [signed] - 输入是否是有符号字节（默认 false）
 * @param {boolean} [littleEndian] - 是否小端序（默认 false）
 * @returns {number} 长整数（注意超出 2^53 可能有精度丢失）
 */
function bytesToLong(bytes, signed, littleEndian) {
  if (bytes.length !== 8) {
    throw new Error("字节数组长度必须为 8");
  }
  signed = typeof signed !== 'undefined' ? signed : false;
  littleEndian = typeof littleEndian !== 'undefined' ? littleEndian : false;

  var hexParts = [];
  for (var i = 0; i < 8; i++) {
    var byteValue = bytes[i];
    // 处理有符号字节
    if (signed && byteValue < 0) {
      byteValue += 256;
    }
    hexParts.push(('0' + byteValue.toString(16)).slice(-2));
  }

  // 调整端序：小端序需反转拼接
  if (littleEndian) {
    hexParts.reverse();
  }

  var hex = hexParts.join('');
  return parseInt(hex, 16);
}

// ----------------- 测试用例 -----------------
// 测试大端序有符号字节（模拟 Java）
var timestamp = 1743656342584;
var bytesSigned = longToBytes(timestamp, true, false);
console.log('大端序有符号字节:', bytesSigned); 
// 输出: Int8Array [0, 0, 1, -107, -6, 4, 84, 56]

var restored = bytesToLong(bytesSigned, true, false);
console.log('还原长整数:', restored); // 1743656342584