node.js - 使用按位运算符时，真实条件是什么意思

Question

在 js 代码端口上工作，我在处理按位运算时遇到困难。

有一个 if 条件，我不确定我是否完全理解。

我不明白的条件是

if (byteUnderConsideration & Math.pow(2, (7 - bitIndexWithinByte))) return node.right

我不知道在那种情况下什么时候会是真的。

完整的原始代码是，

KBucket.prototype._determineNode = function (node, id, bitIndex) {
  // **NOTE** remember that id is a Buffer and has granularity of
  // bytes (8 bits), whereas the bitIndex is the _bit_ index (not byte)

  // id's that are too short are put in low bucket (1 byte = 8 bits)
  // parseInt(bitIndex / 8) finds how many bytes the bitIndex describes
  // bitIndex % 8 checks if we have extra bits beyond byte multiples
  // if number of bytes is <= no. of bytes described by bitIndex and there
  // are extra bits to consider, this means id has less bits than what
  // bitIndex describes, id therefore is too short, and will be put in low
  // bucket
  var bytesDescribedByBitIndex = ~~(bitIndex / 8)
  var bitIndexWithinByte = bitIndex % 8
  if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) return node.left

  var byteUnderConsideration = id[bytesDescribedByBitIndex]

  // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
  // where 255 is 11111111 and 0 is 00000000
  // in order to find out whether the bit at bitIndexWithinByte is set
  // we construct Math.pow(2, (7 - bitIndexWithinByte)) which will consist
  // of all bits being 0, with only one bit set to 1
  // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
  // Math.pow(2, (7 - 3)) -> Math.pow(2, 4) -> 16
  if (byteUnderConsideration & Math.pow(2, (7 - bitIndexWithinByte))) return node.right

  return node.left
}

移植的代码是，

func (K *KBucket) determineNode(node *KBucketNode, id []byte, bitIndex int) *KBucketNode {
    if len(id) < 20 {
        panic(fmt.Errorf("id length must be 20, got %v", id))
    }
    // **NOTE** remember that id is a Buffer and has granularity of
    // bytes (8 bits), whereas the bitIndex is the _bit_ index (not byte)

    // id's that are too short are put in low bucket (1 byte = 8 bits)
    // parseInt(bitIndex / 8) finds how many bytes the bitIndex describes
    // bitIndex % 8 checks if we have extra bits beyond byte multiples
    // if number of bytes is <= no. of bytes described by bitIndex and there
    // are extra bits to consider, this means id has less bits than what
    // bitIndex describes, id therefore is too short, and will be put in low
    // bucket
    bytesDescribedByBitIndex := int(math.Floor(float64(bitIndex) / 8))
    bitIndexWithinByte := float64(bitIndex % 8)
    if len(id) <= bytesDescribedByBitIndex && bitIndexWithinByte != 0 {
        return node.left
    }

    byteUnderConsideration := id[bytesDescribedByBitIndex]

    // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
    // where 255 is 11111111 and 0 is 00000000
    // in order to find out whether the bit at bitIndexWithinByte is set
    // we construct Math.pow(2, (7 - bitIndexWithinByte)) which will consist
    // of all bits being 0, with only one bit set to 1
    // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
    // Math.pow(2, (7 - 3)) -> Math.pow(2, 4) -> 16
    y := int(byteUnderConsideration) & int(math.Pow(2, (7-bitIndexWithinByte)))
    if y > 0 {
        return node.right
    }

    return node.left
}

我通常不执行这种计算，这一切都不清楚，而且我无法正确确定打印它们以开始理解逻辑的正确方法。

谢谢!

Answer 1

首先，如果您正在研究位，那么而不是:

x * 8
x / 8

也许可以:

x << 3
x >> 3

这将使意图更加明确。

此外，使用它没有多大意义:

byteUnderConsideration & Math.pow(2, (7 - bitIndexWithinByte))

什么时候你可以这样做:

byteUnderConsideration & (1 << (7 - bitIndexWithinByte))

这会更加清晰(更不用说它会更加高效)。

<<运算符将位向左移动 >>向右移动。

&运算符对同一位置上的位和 | 进行 AND 运算运算符对位进行或运算。

您确实应该花一些时间阅读 JavaScript 中的按位运算符(其工作方式与 C 中的几乎相同)，因为您会创建很多奇怪的结构，例如:

~~(x / 8)

这可以是:

x >> 3

和~~ (否定两次)将不需要，因为您已经有一个整数。此外，即使您需要强制转换为整数，而不是执行 ~~x你最好这样做x|0 - 查看组合运算符~~之间的区别和|0这里:

• http://asmjs.org/spec/latest/