在 JavaScript 中，可以使用位移来隔离一个字节中的 1 个或多个位吗？

Question

在 JavaScript 代码中，一个字节的 8 位代表 8 个布尔“决策”（又名：标志），需要隔离每个给定位以转换为布尔变量。考虑我使用字符串解析的解决方案：

var bitParser = function (_nTestByte, _nBitOrdinal) {
  var bits = ("00000000" + _nTestByte.toString(2)).slice(-8); // convert to binary and zero-pad
  return bits[_nBitOrdinal] === "1";
};

console.log(bitParser(0b10100101, 2)); // ECMAScript 6+ prefix, returns true

它有效，并显示了所需的结果。但是，我有一个假设，即位移技术将是比字符串操作更快的选择。我倾向于相信这一点，但渴望证明这一点。

问题是，我还没有生成这样一个可以正常工作的函数，更不用说我可以测试的东西了。我创建了以下我认为准确的逻辑计划：

/*
  LOGIC PLAN
  ----------
  0) Remember: all bitwise operators return 32 bits even though we are using 8
  1) Left shift until the desired bit is the left-most (highest) position;
  2) Right shift (zero filling) 31 bits to eliminate all right bits
*/

登录计划的实施如下。由于按位运算符的 32 位性质，我认为在我们到达正在处理的字节之前，必须首先移出整个左侧 3 个字节（24 位）。然后，假设左起第 3 位（字符串序号 2）是所需位，我将再移出 2 位（序号 0 和 1），总共左移 26 位。

这应该产生一个二进制数，其中所需的位一直在左边，后面跟着 31 个不需要的零字节。将这 31 位右移会产生一个具有 31 个（现在）前导零位的二进制文件，其计算结果为所需位的值。但是，当然，如果那是真的，我不会写这个问题，现在我会吗？ :-)

// hardcoded, assuming the second "1" (ordinal 2) is the bit to be examined
console.log((0b10100101 << 26) >> 31); // instead of 1, returns -1

我觉得我真的很接近，但错过了一些东西或者太用力地推动 JavaScript (lol)。

Answer 1

在 JavaScript 代码中，一个字节的 8 位代表 8 个布尔“决策”（又名：标志），需要隔离每个给定位以转换为布尔变量...

如果这是实际目标，则位移既没有必要也没有用：只需使用带有所需位的按位&，这将为您提供0 或设置了该位的数字。 0 是假的，设置位的数字是真的。您可以按原样使用它，也可以通过!!flag 或Boolean(flag) 强制它为布尔值：

这是您使用位掩码的bitParser 函数：

var bitParser = function (_nTestByte, _nBitOrdinal) {
  return !!(_nTestByte & Math.pow(2, _nBitOrdinal));
};
console.log(bitParser(0b10100101, 2)); // true
console.log(bitParser(0b10100101, 1)); // false

当然，与其每次都使用Math.pow，不如使用查找表：

var bits = [
  0b00000001,
  0b00000010,
  0b00000100,
  0b00001000,
  0b00010000,
  0b00100000,
  0b01000000,
  0b10000000
];
var bitParser = function (_nTestByte, _nBitOrdinal) {
  return !!(_nTestByte & bits[_nBitOrdinal]);
};
console.log(bitParser(0b10100101, 2)); // true
console.log(bitParser(0b10100101, 1)); // false

Answer 2

从你的问题中我接受了

console.log((0b10100101 << 26) >> 31); //instead of 1, returns -1.

并回答您的问题，为什么它返回 -1 而不是 1

你需要做无符号右移>>>而不是有符号的>>

console.log((0b10100101 << 26 ) >>>31);

Answer 3

是的，它可以，而且你所做的几乎是正确的。

整数表示为 32 位二进制数，最左边的位表示符号（如果数字为负数则为 1，如果数字为正数则​​为 0）。让我们看一些数字的表示：

//last 31 digits keeps increasing as the number decreases
// ...
-2 => 0b11111111111111111111111111111110
-1 => 0b11111111111111111111111111111111
 0 => 0b00000000000000000000000000000000
 1 => 0b00000000000000000000000000000001
 2 => 0b00000000000000000000000000000010
// ...
// last 31 digits keep increasing as the number increases

现在，您所拥有的(0b10100101 << 26) 应该给您10010100000000000000000000000000，您会认为它是一个很大的负数（因为最左边的位是1）。然后紧接着，你有>> 31，你希望去掉所有的 31 位并留下最左边的位。

这应该可行，但事实并非如此。那为什么呢？这是因为提出 ECMAScript 的人认为如果 4 >> 1 返回 2 和 -4 >> 1 返回 -2 会更有意义。

4 >> 1 // returns 2 which is 0b00000000000000000000000000000010
0b0000000000000000000000000000000100 >> 1 // returns 2, same

-4 >> 1 // returns -2, which is 0b11111111111111111111111111111110

但是 -4 是 0b11111111111111111111111111111100，为了您的目的，将它右移 1 应该得到 0b01111111111111111111111111111110（大正数，因为左后位是 0），这不是 -2！

要克服这个问题，您可以使用另一个不关心符号的右移运算符：>>>。 -4 >>> 1 是 2147483646，这是我们想要的。

所以console.log((0b10100101 << 26) >>> 31); 给你1，这就是你想要的。您也可以继续使用>>，并将任何负面结果视为1 被选中的结果。

Answer 4

实现您的实际需求最简单的方法是使用简单的条件，而不是试图隔离位。

    var bitParser = function (_nTestByte, _nBitOrdinal) {
      return (_nTestByte & _nBitOrdinal);
    };
    
    console.log(bitParser(6, 2) ? true : false); // true
    console.log(bitParser(6, 1) ? true : false); // false

我以一种看似复杂的方式调整了console.log() 表达式。
这一步只是为了真正显示逻辑结果，而我没有选择在函数内部使用!!，所以返回一个真/假值而不是true|@987654325 @。

实际上这种方式尽可能保持最简单，因为代码中的 else where 预期使用 if (bitParser(...))，它会自动将结果转换为布尔值。

顺便说一句，无论_nTestByte 大小（可能超过 1 个字节），这都有效。