JavaScript中字节数组位移操作的32位陷阱与解决方案

func ShiftLeft(b []byte) []byte {
    l := len(b)
    if l == 0 {
        panic("shiftLeft requires a non-empty buffer.")
    }

    output := make([]byte, l)

    overflow := byte(0)
    for i := int(l - 1); i >= 0; i-- {
        output[i] = b[i] << 1
        output[i] |= overflow
        overflow = (b[i] & 0x80) >> 7 // 获取当前字节的最高位作为溢出位
    }

    return output
}

function makeEmpty(size) {
  var result = [];
  for (var i = 0; i < size; i++) {
    result.push(0x00);
  }
  return result;
}

function shiftLeft (b) {
  var len = b.length;
  if (len === 0) {
    throw 'shiftLeft requires a non-empty buffer';
  }

  var output = makeEmpty(len);
  var overflow = 0;

  for (var i = len - 1; i >= 0; i--) {
    output[i] = b[i] << 1; // 问题所在：此处结果可能超出8位
    output[i] |= overflow;
    overflow = (b[i] & 0x80) >> 7; // 获取当前字节的最高位作为溢出位
  }
  return output;
}

function fromBinary(str) { // 原始函数名为fromOctal，但根据用途应为fromBinary
  var bytes = [parseInt(str, 2)];
  return bytes;
}

console.log(shiftLeft(fromBinary("10000000")));
// 预期结果：[0] 或 "00000000"
// 实际结果：[256]

output[i] = (b[i] << 1) & 0xFF;

/**
 * 创建一个指定大小的空字节数组（初始化为0）。
 * @param {number} size 数组大小。
 * @returns {Array} 初始化后的字节数组。
 */
function makeEmpty(size) {
  var result = [];
  for (var i = 0; i < size; i++) {
    result.push(0x00);
  }
  return result;
}

/**
 * 将字节数组进行左移一位操作，并处理溢出位。
 * 模拟Go语言中对[]byte的位移行为。
 * @param {Array} b 输入的字节数组，元素应为0-255之间的整数。
 * @returns {Array} 左移后的字节数组。
 * @throws {string} 如果输入数组为空。
 */
function shiftLeft (b) {
  var len = b.length;
  if (len === 0) {
    throw 'shiftLeft requires a non-empty buffer';
  }

  var output = makeEmpty(len);
  var overflow = 0; // 存储从前一个字节溢出的最高位

  // 从数组的最后一个字节（最低位）开始处理，向前遍历
  for (var i = len - 1; i >= 0; i--) {
    // 1. 将当前字节左移一位，并使用0xFF掩码确保结果保持在8位范围内
    //    例如：10000000 (128) << 1 = 00000001 00000000 (256)
    //    (256) & 0xFF = 00000000 (0)
    output[i] = (b[i] << 1) & 0xFF;

    // 2. 将从前一个字节传递过来的溢出位（如果存在）合并到当前字节的最低位
    output[i] |= overflow;

    // 3. 计算当前字节的最高位，作为溢出位传递给下一个（高位）字节
    //    0x80 (10000000) 用于检查第8位（最高位）
    //    >> 7 将最高位移动到最低位，得到0或1
    overflow = (b[i] & 0x80) >> 7;
  }

  return output;
}

/**
 * 从二进制字符串创建字节数组。
 * @param {string} str 二进制字符串，如 "10000000"。
 * @returns {Array} 包含解析后的字节的数组。
 */
function fromBinary(str) {
  // parseInt(str, 2) 将二进制字符串转换为整数
  var bytes = [parseInt(str, 2)];
  return bytes;
}

// 测试用例
console.log("原始字节数组 (二进制 10000000):", fromBinary("10000000")); // 输出: [128]
console.log("左移一位后的结果:", shiftLeft(fromBinary("10000000"))); // 预期输出: [0]

console.log("-----------------------------------");

// 另一个测试用例: [01010101] (85)
console.log("原始字节数组 (二进制 01010101):", fromBinary("01010101")); // 输出: [85]
console.log("左移一位后的结果:", shiftLeft(fromBinary("01010101"))); // 预期输出: [170] (10101010)

console.log("-----------------------------------");

// 多字节数组测试用例: [00000001, 10000000] ([1, 128])
// 预期结果: [00000011, 00000000] ([3, 0])
// 128 << 1 = 0, 溢出1
// 1 << 1 = 2, 加上溢出1 = 3
console.log("原始字节数组:", [1, 128]);
console.log("左移一位后的结果:", shiftLeft([1, 128])); // 预期输出: [3, 0]