test();
    function test() {
        var bytes = getFloat64Bytes(-3.33);
        alert(bytes);
        alert(toFloat64(bytes));
    }
    //構(gòu)建一個視圖，把字節(jié)數(shù)組寫到緩存中，索引從0開始，大端字節(jié)序
    function getView(bytes) {
        var view = new DataView(new ArrayBuffer(bytes.length));
        for (var i = 0; i < bytes.length; i++) {
            view.setUint8(i, bytes[i]);
        }
        return view;
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成有符號的8位整型，大端字節(jié)序
    function toInt8(bytes) {
        return getView(bytes).getInt8();
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成無符號的8位整型，大端字節(jié)序
    function toUint8(bytes) {
        return getView(bytes).getUint8();
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成有符號的16位整型，大端字節(jié)序
    function toInt16(bytes) {
        return getView(bytes).getInt16();
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成無符號的16位整型，大端字節(jié)序
    function toUint16(bytes) {
        return getView(bytes).getUint16();
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成有符號的32位整型，大端字節(jié)序
    function toInt32(bytes) {
        return getView(bytes).getInt32();
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成無符號的32位整型，大端字節(jié)序
    function toUint32(bytes) {
        return getView(bytes).getUint32();
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成32位浮點型，大端字節(jié)序
    function toFloat32(bytes) {
        return getView(bytes).getFloat32();
    }
    //將字節(jié)數(shù)組轉(zhuǎn)成64位浮點型，大端字節(jié)序
    function toFloat64(bytes) {
        return getView(bytes).getFloat64();
    }
    //將數(shù)值寫入到視圖中，獲得其字節(jié)數(shù)組，大端字節(jié)序
    function getUint8Array(len, setNum) {
        var buffer = new ArrayBuffer(len);  //指定字節(jié)長度
        setNum(new DataView(buffer));  //根據(jù)不同的類型調(diào)用不同的函數(shù)來寫入數(shù)值
        return new Uint8Array(buffer); //創(chuàng)建一個字節(jié)數(shù)組，從緩存中拿取數(shù)據(jù)
    }
    //得到一個8位有符號整型的字節(jié)數(shù)組，大端字節(jié)序
    function getInt8Bytes(num) {
        return getUint8Array(1, function (view) { view.setInt8(0, num); })
    }
    //得到一個8位無符號整型的字節(jié)數(shù)組，大端字節(jié)序
    function getUint8Bytes(num) {
        return getUint8Array(1, function (view) { view.setUint8(0, num); })
    }
    //得到一個16位有符號整型的字節(jié)數(shù)組，大端字節(jié)序
    function getInt16Bytes(num) {
        return getUint8Array(2, function (view) { view.setInt16(0, num); })
    }
    //得到一個16位無符號整型的字節(jié)數(shù)組，大端字節(jié)序
    function getUint16Bytes(num) {
        return getUint8Array(2, function (view) { view.setUint16(0, num); })
    }
    //得到一個32位有符號整型的字節(jié)數(shù)組，大端字節(jié)序
    function getInt32Bytes(num) {
        return getUint8Array(4, function (view) { view.setInt32(0, num); })
    }
    //得到一個32位無符號整型的字節(jié)數(shù)組，大端字節(jié)序
    function getUint32Bytes(num) {
        return getUint8Array(4, function (view) { view.setUint32(0, num); })
    }
    //得到一個32位浮點型的字節(jié)數(shù)組，大端字節(jié)序
    function getFloat32Bytes(num) {
        return getUint8Array(4, function (view) { view.setFloat32(0, num); })
    }
    //得到一個64位浮點型的字節(jié)數(shù)組，大端字節(jié)序
    function getFloat64Bytes(num) {
        return getUint8Array(8, function (view) { view.setFloat64(0, num); })
    }
    ////下面幾個為另一種實現(xiàn)方式的版本，只實現(xiàn)了簡單幾種，其他的實現(xiàn)起來比較麻煩，所以就中途放棄了
    //function toInt32(bytes) {
    //    return ((bytes[0] & 0xFF) << 24) | ((bytes[1] & 0xFF) << 16) | ((bytes[2] & 0xFF) << 8) | (bytes[3] & 0xFF);
    //}
    //function toUInt16(bytes) {
    //    return ((bytes[0] & 0xFF) << 8) | (bytes[1] & 0xFF);
    //}
    //function toInt16(bytes) {
    //    return bytes[0] >> 7 == 0 ? toUInt16(bytes) : toUInt16(bytes) - 65536;
    //}
    //function getInt32Bytes(num) {
    //    return [num >> 24 & 0xFF, num >> 16 & 0xFF, num >> 8 & 0xFF, num & 0xFF];
    //}
    //function getUint16Bytes(num) {
    //    return [num >> 8 & 0xFF, num & 0xFF];
    //}
    //function getInt16Bytes(num) {
    //    return num >= 0 ? getUint16Bytes(num) : getUint16Bytes(65536 + num);
    //}

//將數(shù)值寫入到視圖中，獲得其字節(jié)數(shù)組，大端字節(jié)序
    function getUint8Array(len, setNum) {
        var buffer = new ArrayBuffer(len); //指定字節(jié)長度
        setNum(new DataView(buffer)); //根據(jù)不同的類型調(diào)用不同的函數(shù)來寫入數(shù)值
        var uint8Array = new Uint8Array(buffer); //創(chuàng)建一個字節(jié)數(shù)組，從緩存中拿取數(shù)據(jù)
        var arr = new Array();  //將Uint8Array轉(zhuǎn)成Array數(shù)組，不考慮性能問題
        for (var i = 0; i < uint8Array.byteLength; i++) {  //尷尬,Uint8Array沒有l(wèi)ength，只有byteLength，之前寫的竟然沒測就發(fā)布了，現(xiàn)在才發(fā)現(xiàn)問題
            arr.push(uint8Array[i]);
        }
        return arr;
    }

/**
 * 將64位長整數(shù)轉(zhuǎn)換為8字節(jié)數(shù)組（支持符號和字節(jié)序）
 * @param {BigInt} long - 輸入的長整數(shù)
 * @param {Object} [options] - 配置項
 * @param {boolean} [options.signed=false] - 是否生成有符號字節(jié)
 * @param {boolean} [options.littleEndian=false] - 是否小端序
 * @returns {Uint8Array|Int8Array} 字節(jié)數(shù)組
 */
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);
  // 讀取字節(jié)
  const bytes = signed ? 
    new Int8Array(buffer) : 
    new Uint8Array(buffer);
  return bytes;
}

/**
 * 將字節(jié)數(shù)組轉(zhuǎn)換為長整數(shù)
 * @param {Uint8Array|Int8Array} bytes - 輸入的8字節(jié)數(shù)組
 * @param {Object} [options] - 配置項 
 * @param {boolean} [options.signed=false] - 是否解析為有符號數(shù)
 * @param {boolean} [options.littleEndian=false] - 是否小端序
 * @returns {BigInt} 解析后的長整數(shù)
 */
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;
// 轉(zhuǎn)換為有符號字節(jié)數(shù)組（模擬 Java 的 byte[]）
const bytesSigned = longToBytes(timestamp, true); // 默認(rèn)大端序
console.log("有符號字節(jié)數(shù)組:", bytesSigned); 
// 輸出: Int8Array [0, 0, 1, -107, -6, 4, 84, 56] （與 Java 一致）
// 還原長整數(shù)
const restored = bytesToLong(bytesSigned, true);
console.log("還原結(jié)果:", restored.toString()); // 1743656342584n

/**
 * 將長整數(shù)轉(zhuǎn)換為 8 字節(jié)數(shù)組（ES5 語法，兼容有符號字節(jié)）
 * @param {number} long - 長整數(shù)（需在 2^53 范圍內(nèi)確保精度）
 * @param {boolean} [signed] - 是否輸出有符號字節(jié)（默認(rèn) false）
 * @param {boolean} [littleEndian] - 是否小端序（默認(rèn) false）
 * @returns {Int8Array|Uint8Array} 8 字節(jié)數(shù)組
 */
function longToBytes(long, signed, littleEndian) {
  signed = typeof signed !== 'undefined' ? signed : false;
  littleEndian = typeof littleEndian !== 'undefined' ? littleEndian : false;
  // 轉(zhuǎn)換為 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++) {
    // 計算字節(jié)位置
    var pos = littleEndian ? (7 - i) : i;
    var byteStr = hex.substr(pos * 2, 2);
    var byteValue = parseInt(byteStr, 16);
    // 處理有符號字節(jié)
    if (signed && byteValue > 127) {
      byteValue -= 256;
    }
    bytes[i] = byteValue;
  }
  return bytes;
}

/**
 * 將字節(jié)數(shù)組轉(zhuǎn)換為長整數(shù)（ES5 語法，兼容有符號字節(jié)）
 * @param {Int8Array|Uint8Array} bytes - 8 字節(jié)數(shù)組
 * @param {boolean} [signed] - 輸入是否是有符號字節(jié)（默認(rèn) false）
 * @param {boolean} [littleEndian] - 是否小端序（默認(rèn) false）
 * @returns {number} 長整數(shù)（注意超出 2^53 可能有精度丟失）
 */
function bytesToLong(bytes, signed, littleEndian) {
  if (bytes.length !== 8) {
    throw new Error("字節(jié)數(shù)組長度必須為 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];
    // 處理有符號字節(jié)
    if (signed && byteValue < 0) {
      byteValue += 256;
    }
    hexParts.push(('0' + byteValue.toString(16)).slice(-2));
  }
  // 調(diào)整端序：小端序需反轉(zhuǎn)拼接
  if (littleEndian) {
    hexParts.reverse();
  }
  var hex = hexParts.join('');
  return parseInt(hex, 16);
}

// ----------------- 測試用例 -----------------
// 測試大端序有符號字節(jié)（模擬 Java）
var timestamp = 1743656342584;
var bytesSigned = longToBytes(timestamp, true, false);
console.log('大端序有符號字節(jié):', bytesSigned); 
// 輸出: Int8Array [0, 0, 1, -107, -6, 4, 84, 56]
var restored = bytesToLong(bytesSigned, true, false);
console.log('還原長整數(shù):', restored); // 1743656342584