将短十六进制字符串无损存储为JavaScript双精度浮点数教程

/**
 * 将十六进制字符串转换为字节数组。
 * 例如："0123456789abcdef12345678" -> [1, 35, 69, 103, 137, 171, 205, 239, 18, 52, 86, 120]
 * @param {string} hexString - 输入的十六进制字符串，长度必须为偶数。
 * @returns {number[]} - 包含字节值的数组。
 */
function hexStringToBytes(hexString) {
    if (hexString.length % 2 !== 0) {
        throw new Error("十六进制字符串长度必须为偶数。");
    }
    const bytes = [];
    for (let i = 0; i < hexString.length; i += 2) {
        bytes.push(parseInt(hexString.substr(i, 2), 16));
    }
    return bytes;
}

/**
 * 将字节数组转换为十六进制字符串。
 * 例如：[1, 35, 69, 103, 137, 171, 205, 239, 18, 52, 86, 120] -> "0123456789abcdef12345678"
 * @param {number[]} bytes - 包含字节值的数组。
 * @returns {string} - 还原的十六进制字符串。
 */
function bytesToHexString(bytes) {
    return Array.from(bytes, function(byte) {
        // 确保每个字节都格式化为两位十六进制数
        return ('0' + (byte & 0xFF).toString(16)).slice(-2);
    }).join('');
}

/**
 * 将12字节的数组编码为两个双精度浮点数。
 * 每个双精度浮点数存储6个字节。
 * @param {number[]} bytes - 12字节的数组。
 * @returns {number[]} - 包含两个双精度浮点数的数组。
 */
function bytesToDoubles(bytes) {
    if (bytes.length !== 12) {
        throw new Error("输入字节数组长度必须为12。");
    }
    let doubles = [0.0, 0.0];
    for (let i = 0; i < 2; i++) { // 遍历两个double变量
        for (let j = 0; j < 6; j++) { // 每个double存储6个字节
            // 累加字节，并除以256，将字节推入小数部分
            doubles[i] = (doubles[i] + bytes[6 * i + j]) / 256;
        }
    }
    return doubles;
}

/**
 * 将两个双精度浮点数解码回12字节的数组。
 * @param {number[]} doubles - 包含两个双精度浮点数的数组。
 * @returns {number[]} - 还原的12字节数组。
 */
function doublesToBytes(doubles) {
    if (doubles.length !== 2) {
        throw new Error("输入双精度浮点数数组长度必须为2。");
    }
    let bytes = new Array(12); // 初始化一个12字节的数组
    for (let i = 0; i < 2; i++) { // 遍历两个double变量
        let d = doubles[i];
        // 从最低有效字节开始提取，所以j从5到0
        for (let j = 5; j >= 0; j--) {
            d = 256 * d; // 将下一个字节移到整数部分
            bytes[6 * i + j] = Math.floor(d); // 提取整数部分作为字节
            d -= Math.floor(d); // 移除已提取的字节，保留小数部分
        }
    }
    return bytes;
}

// 1. 原始输入：12字节的十六进制字符串
const originalHexString = "0123456789abcdef12345678";
console.log("原始十六进制字符串:", originalHexString);

// 2. 将十六进制字符串转换为字节数组
const bytesArray = hexStringToBytes(originalHexString);
console.log("转换为字节数组:", bytesArray);

// 3. 将字节数组编码为双精度浮点数
const encodedDoubles = bytesToDoubles(bytesArray);
console.log("编码为双精度浮点数:", encodedDoubles);
// 此时 encodedDoubles 可以存储到时间序列数据库中

// 4. 从双精度浮点数解码回字节数组
const decodedBytes = doublesToBytes(encodedDoubles);
console.log("解码回字节数组:", decodedBytes);

// 5. 将字节数组转换回十六进制字符串
const restoredHexString = bytesToHexString(decodedBytes);
console.log("还原的十六进制字符串:", restoredHexString);

// 6. 验证无损性
if (originalHexString === restoredHexString) {
    console.log("验证成功：数据无损还原！");
} else {
    console.error("验证失败：数据还原不一致！");
}

// 随机数据测试
console.log("\n--- 随机数据测试 ---");
let randomBytes = [];
for (let i = 0; i < 12; i++) {
    randomBytes.push(Math.floor(Math.random() * 256));
}
console.log("随机字节数组:", randomBytes);
const randomDoubles = bytesToDoubles(randomBytes);
console.log("编码为双精度浮点数:", randomDoubles);
const decodedRandomBytes = doublesToBytes(randomDoubles);
console.log("解码回字节数组:", decodedRandomBytes);

if (JSON.stringify(randomBytes) === JSON.stringify(decodedRandomBytes)) {
    console.log("随机数据测试成功：数据无损还原！");
} else {
    console.error("随机数据测试失败：数据还原不一致！");
}