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 // Go's byte << 1 naturally handles 8-bit overflow
        output[i] |= overflow
        overflow = (b[i] & 0x80) >> 7
    }
    return output
}

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

  var output = makeEmpty(len); // 假设 makeEmpty 返回一个填充0的数组
  var overflow = 0;

  for (var i = len - 1; i >= 0; i--) {
    output[i] = b[i] << 1; // 问题所在：这里的结果可能是32位
    output[i] |= overflow;
    overflow = (b[i] & 0x80) >> 7;
  }
  return output;
}

// 辅助函数：创建一个填充0的数组
function makeEmpty(size) {
  var result = [];
  for (var i = 0; i < size; i++) {
    result.push(0x00);
  }
  return result;
}

// 辅助函数：将二进制字符串转换为字节数组（此处仅处理单个字节）
// 注意：原问题中的 fromOctal 应为 fromBinary
function fromBinary(str) {
  // parseInt(str, 2) 将二进制字符串解析为整数
  var bytes = [parseInt(str, 2)];
  return bytes;
}

console.log(shiftLeft(fromBinary("10000000"))); // 预期 [0]，实际 [256]

output[i] = b[i] << 1;

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

/**
 * 创建一个指定大小的字节数组，并用0填充。
 * @param {number} size 数组大小。
 * @returns {number[]} 填充0的字节数组。
 */
function makeEmpty(size) {
  var result = [];
  for (var i = 0; i < size; i++) {
    result.push(0x00); // 0x00 等同于 0
  }
  return result;
}

/**
 * 对字节数组执行左移操作，模拟8位整数溢出。
 * @param {number[]} b 待左移的字节数组。
 * @returns {number[]} 左移后的字节数组。
 * @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; // 溢出位，0或1

  // 从数组末尾（最低有效字节）开始处理
  for (var i = len - 1; i >= 0; i--) {
    // 1. 将当前字节左移一位，并用 & 0xFF 确保结果截断为8位
    var shiftedValue = (b[i] << 1) & 0xFF;

    // 2. 将前一个字节（或初始的0）的溢出位合并到当前字节
    output[i] = shiftedValue | overflow;

    // 3. 计算当前字节的最高位，作为下一个字节的溢出位
    // (b[i] & 0x80) 提取第8位 (最高位)
    // >> 7 将其右移7位，使其成为0或1
    overflow = (b[i] & 0x80) >> 7;
  }

  return output;
}

/**
 * 将二进制字符串转换为字节数组（此处仅处理单个字节）。
 * @param {string} str 二进制字符串，如 "10000000"。
 * @returns {number[]} 对应的字节数组。
 */
function fromBinary(str) {
  // parseInt(str, 2) 将二进制字符串解析为整数
  // 确保结果也是8位，尽管这里对于单个字节通常不是问题
  var bytes = [parseInt(str, 2) & 0xFF]; 
  return bytes;
}

// 测试用例
console.log("输入: [128] (二进制 10000000)");
console.log("输出:", shiftLeft(fromBinary("10000000"))); // 预期: [0]

console.log("\n输入: [1] (二进制 00000001)");
console.log("输出:", shiftLeft(fromBinary("00000001"))); // 预期: [2]

console.log("\n输入: [255] (二进制 111111