13.10 位运算库 (Bit32 Library - Lua 5.2+)

13.10 位运算库 (Bit32 Library - Lua 5.2+)

Lua 5.2+ 位运算库 (Bit32 Library) 详解与实践

在 Lua 5.2 版本及之后，标准库中引入了 bit32 库，专门用于处理 32 位整数的位运算。这个库的出现弥补了早期 Lua 版本在位操作方面的不足，为开发者提供了更高效、更便捷的方式来进行底层数据处理、网络协议解析、以及各种需要位级操作的应用场景。

1. 为什么需要位运算库？

在计算机科学中，位运算直接操作二进制数据的位，具有极高的效率。在很多场景下，位运算比传统的算术运算和逻辑运算更快速，且能实现一些特殊的功能，例如：

• 底层数据处理: 处理二进制文件、网络数据包、硬件寄存器等，需要直接操作数据的位。

• 标志位 (Flags) 管理: 使用位来表示和组合多个布尔状态，节省空间且高效。

• 哈希计算和校验和: 位运算常用于构建高效的哈希算法和校验和算法。

• 加密算法: 许多加密算法的核心操作都涉及到大量的位运算。

• 性能优化: 在某些性能敏感的应用中，使用位运算可以替代耗时的乘除法和取模运算。

Lua 早期版本虽然也支持一些位运算，但效率较低，功能也有限。bit32 库的引入，使得 Lua 在处理位运算方面更加强大和高效，尤其是在需要处理 32 位无符号整数的场景下。

2. Bit32 库概览

bit32 库提供了一系列函数，用于操作 32 位无符号整数。所有函数都位于 bit32 表中。以下是 bit32 库的主要函数列表：

• 逻辑运算:

  • bit32.band (...): 按位与 (AND)

  • bit32.bor (...): 按位或 (OR)

  • bit32.bxor (...): 按位异或 (XOR)

  • bit32.bnot (x): 按位取反 (NOT)

• 位移运算:

  • bit32.lshift (x, n): 逻辑左移 (Left Shift)

  • bit32.rshift (x, n): 逻辑右移 (Right Shift)

  • bit32.arshift (x, n): 算术右移 (Arithmetic Right Shift)

  • bit32.rol (x, n): 循环左移 (Rotate Left)

  • bit32.ror (x, n): 循环右移 (Rotate Right)

• 位域操作:

  • bit32.extract (x, field [, width [, signed]]): 提取位域

  • bit32.replace (x, v, field [, width]): 替换位域

• 字节序转换:

  • bit32.bswap (x): 字节序交换 (Byte Swap)

• 类型转换:

  • bit32.tobn (x): 转换为 number 类型 (在 LuaJIT 中，它返回一个 32 位 number)

  • bit32.tohex (x [, n]): 转换为十六进制字符串

3. 逻辑运算详解与实践

逻辑运算是最基础的位运算，bit32 库提供了 band, bor, bxor, bnot 四个函数。

3.1. bit32.band (...) - 按位与 (AND)

• 功能: 对多个整数进行按位与运算。只有当参与运算的所有数的对应位都为 1 时，结果的对应位才为 1，否则为 0。

• 语法: bit32.band (x1, x2, ...)

• 参数: 可以接受一个或多个 32 位整数。

• 返回值: 按位与运算的结果。

代码示例:

local a = 0b10110101 -- 181
local b = 0b11001100 -- 204
local c = 0b01010101 -- 85
local result1 = bit32.band(a, b)
print(string.format("bit32.band(%d, %d) = %d (0b%b)", a, b, result1, result1)) -- bit32.band(181, 204) = 164 (0b10100100)
local result2 = bit32.band(a, b, c)
print(string.format("bit32.band(%d, %d, %d) = %d (0b%b)", a, b, c, result2, result2)) -- bit32.band(181, 204, 85) = 69 (0b1000101)
​

解释:

• bit32.band(a, b):

    10110101 (a)
  & 11001100 (b)
  ---------
    10100100 (result1 = 164)
  ​

• bit32.band(a, b, c):

    10110101 (a)
  & 11001100 (b)
  & 01010101 (c)
  ---------
    01000101 (result2 = 69)
  ​

应用场景:

• 掩码 (Masking): 使用按位与运算可以提取一个数中的特定位。例如，要提取一个数 x 的低 4 位，可以使用掩码 0xF (二进制 0b1111) 进行按位与运算： bit32.band(x, 0xF)。

• 清零特定位: 将特定位清零，可以使用掩码，掩码在要清零的位上为 0，其他位为 1。例如，要将 x 的低 4 位清零，可以使用掩码 0xFFFFFFF0 (二进制 0b...11110000) 进行按位与运算： bit32.band(x, 0xFFFFFFF0)。

3.2. bit32.bor (...) - 按位或 (OR)

• 功能: 对多个整数进行按位或运算。只要参与运算的数中有一个数的对应位为 1，结果的对应位就为 1，否则为 0。

• 语法: bit32.bor (x1, x2, ...)

• 参数: 可以接受一个或多个 32 位整数。

• 返回值: 按位或运算的结果。

代码示例:

local a = 0b10110101 -- 181
local b = 0b11001100 -- 204
local c = 0b01010101 -- 85
local result1 = bit32.bor(a, b)
print(string.format("bit32.bor(%d, %d) = %d (0b%b)", a, b, result1, result1)) -- bit32.bor(181, 204) = 221 (0b11011101)
local result2 = bit32.bor(a, b, c)
print(string.format("bit32.bor(%d, %d, %d) = %d (0b%b)", a, b, c, result2, result2)) -- bit32.bor(181, 204, 85) = 253 (0b11111101)
​

解释:

• bit32.bor(a, b):

    10110101 (a)
  | 11001100 (b)
  ---------
    11011101 (result1 = 221)
  ​

• bit32.bor(a, b, c):

    10110101 (a)
  | 11001100 (b)
  | 01010101 (c)
  ---------
    11111101 (result2 = 253)
  ​

应用场景:

• 设置特定位: 使用按位或运算可以将一个数的特定位设置为 1。例如，要将一个数 x 的低 4 位设置为 1，可以使用掩码 0xF (二进制 0b1111) 进行按位或运算： bit32.bor(x, 0xF)。

• 合并标志位: 当使用位来表示标志位时，可以使用按位或运算来合并多个标志位。

3.3. bit32.bxor (...) - 按位异或 (XOR)

• 功能: 对多个整数进行按位异或运算。当参与运算的数中，对应位的值不同时，结果的对应位为 1，否则为 0。

• 语法: bit32.bxor (x1, x2, ...)

• 参数: 可以接受一个或多个 32 位整数。

• 返回值: 按位异或运算的结果。

代码示例:

local a = 0b10110101 -- 181
local b = 0b11001100 -- 204
local c = 0b01010101 -- 85
local result1 = bit32.bxor(a, b)
print(string.format("bit32.bxor(%d, %d) = %d (0b%b)", a, b, result1, result1)) -- bit32.bxor(181, 204) = 57 (0b111001)
local result2 = bit32.bxor(a, b, c)
print(string.format("bit32.bxor(%d, %d, %d) = %d (0b%b)", a, b, c, result2, result2)) -- bit32.bxor(181, 204, 85) = 124 (0b1111100)
​

解释:

• bit32.bxor(a, b):

    10110101 (a)
  ^ 11001100 (b)
  ---------
    01111001 (result1 = 121)  -- 修正示例输出，原文结果有误
  ​

• bit32.bxor(a, b, c):

    10110101 (a)
  ^ 11001100 (b)
  ^ 01010101 (c)
  ---------
    00101100 (result2 = 44) -- 修正示例输出，原文结果有误
  ​

应用场景:

• 翻转特定位: 使用按位异或运算可以将一个数的特定位翻转 (0 变为 1，1 变为 0)。例如，要将一个数 x 的低 4 位翻转，可以使用掩码 0xF (二进制 0b1111) 进行按位异或运算： bit32.bxor(x, 0xF)。

• 交换两个数的值 (不使用临时变量): 可以使用异或运算来交换两个变量的值，而无需额外的临时变量。

• 简单的加密和解密: 异或运算可以用于简单的加密和解密，因为异或运算具有自反性 ( (a XOR b) XOR b = a )。

3.4. bit32.bnot (x) - 按位取反 (NOT)

• 功能: 对一个整数进行按位取反运算。将数的每一位取反，0 变为 1，1 变为 0。

• 语法: bit32.bnot (x)

• 参数: 一个 32 位整数。

• 返回值: 按位取反运算的结果。

代码示例:

local a = 0b10110101 -- 181
local result = bit32.bnot(a)
print(string.format("bit32.bnot(%d) = %d (0b%b)", a, result, result)) -- bit32.bnot(181) = -182 (0b-10110110)
​

解释:

• bit32.bnot(a):

    10110101 (a)
  ---------
    01001010 (取反后，但这是32位无符号数的取反，Lua 中表示为有符号数，所以结果会是补码形式)
  ​

  由于 bit32 库操作的是 32 位无符号整数，但 Lua 中的 number 类型默认是双精度浮点数 (可以表示整数，但也可能被解释为有符号数)。 bit32.bnot 返回的结果会被解释为有符号数。 对于正数 a，bit32.bnot(a) 实际上是计算 -(a+1) 的补码表示。

应用场景:

• 构建掩码: 按位取反常用于从已有的掩码生成反掩码。例如，如果有一个掩码用于提取特定位，那么取反后的掩码可以用于清零或排除这些位。

• 补码运算: 在一些底层运算中，可能需要用到补码表示，按位取反是计算补码的关键步骤之一。

4. 位移运算详解与实践

位移运算可以将一个数的所有位向左或向右移动指定的位数。bit32 库提供了逻辑左移 (lshift), 逻辑右移 (rshift), 算术右移 (arshift), 循环左移 (rol), 和循环右移 (ror) 五种位移运算。

4.1. bit32.lshift (x, n) - 逻辑左移 (Left Shift)

• 功能: 将整数 x 的所有位向左移动 n 位。右侧空出的位用 0 填充。

• 语法: bit32.lshift (x, n)

• 参数:

  • x: 要进行位移操作的 32 位整数。

  • n: 位移的位数 (非负整数)。

• 返回值: 左移运算的结果。

代码示例:

local a = 0b00000001 -- 1
local result1 = bit32.lshift(a, 1)
print(string.format("bit32.lshift(%d, 1) = %d (0b%b)", a, result1, result1)) -- bit32.lshift(1, 1) = 2 (0b10)
local result2 = bit32.lshift(a, 4)
print(string.format("bit32.lshift(%d, 4) = %d (0b%b)", a, result2, result2)) -- bit32.lshift(1, 4) = 16 (0b10000)
local b = 0b10000000 -- 128
local result3 = bit32.lshift(b, 1)
print(string.format("bit32.lshift(%d, 1) = %d (0b%b)", b, result3, result3)) -- bit32.lshift(128, 1) = 256 (0b100000000)
​

解释:

逻辑左移相当于将数乘以 2 的 n 次方 (在不溢出的情况下)。

应用场景:

• 乘法运算优化: 在某些情况下，左移运算可以替代乘法运算，提高性能。例如，x * 2^n 可以用 bit32.lshift(x, n) 替代。

• 数据格式转换: 在处理某些数据格式时，可能需要将数据左移以调整位的位置。

4.2. bit32.rshift (x, n) - 逻辑右移 (Right Shift)

• 功能: 将整数 x 的所有位向右移动 n 位。左侧空出的位用 0 填充。

• 语法: bit32.rshift (x, n)

• 参数:

  • x: 要进行位移操作的 32 位整数。

  • n: 位移的位数 (非负整数)。

• 返回值: 右移运算的结果。

代码示例:

local a = 0b10000000 -- 128
local result1 = bit32.rshift(a, 1)
print(string.format("bit32.rshift(%d, 1) = %d (0b%b)", a, result1, result1)) -- bit32.rshift(128, 1) = 64 (0b1000000)
local result2 = bit32.rshift(a, 4)
print(string.format("bit32.rshift(%d, 4) = %d (0b%b)", a, result2, result2)) -- bit32.rshift(128, 4) = 8 (0b1000)
local b = 0b11111111 -- 255
local result3 = bit32.rshift(b, 1)
print(string.format("bit32.rshift(%d, 1) = %d (0b%b)", b, result3, result3)) -- bit32.rshift(255, 1) = 127 (0b1111111)
​

解释:

逻辑右移相当于将正数除以 2 的 n 次方 (向下取整)。

应用场景:

• 除法运算优化: 在某些情况下，右移运算可以替代除法运算，提高性能。例如，x // 2^n (整数除法) 可以用 bit32.rshift(x, n) 替代 (对于正数)。

• 提取高位: 右移运算可以用于提取一个数的高位。

4.3. bit32.arshift (x, n) - 算术右移 (Arithmetic Right Shift)

• 功能: 将整数 x 的所有位向右移动 n 位。左侧空出的位用符号位填充 (即最高位的值)。对于正数，算术右移和逻辑右移结果相同。对于负数 (在补码表示下)，算术右移保持符号位不变，逻辑右移则会填充 0，导致结果变为正数。

• 语法: bit32.arshift (x, n)

• 参数:

  • x: 要进行位移操作的 32 位整数。

  • n: 位移的位数 (非负整数)。

• 返回值: 算术右移运算的结果。

代码示例:

local a = 0b10000000 -- 128 (正数，最高位为 0)
local result1 = bit32.arshift(a, 1)
print(string.format("bit32.arshift(%d, 1) = %d (0b%b)", a, result1, result1)) -- bit32.arshift(128, 1) = 64 (0b1000000) (与逻辑右移结果相同)
local b = -0b10000000 -- -128 (负数，最高位为 1，补码表示)
local result2 = bit32.arshift(b, 1)
print(string.format("bit32.arshift(%d, 1) = %d (0b%b)", b, result2, result2)) -- bit32.arshift(-128, 1) = -64 (0b-1000000) (保持负数)
local result3 = bit32.rshift(b, 1) -- 逻辑右移
print(string.format("bit32.rshift(%d, 1) = %d (0b%b)", b, result3, result3)) -- bit32.rshift(-128, 1) = 2147483584 (0b10000000000000000000000000000000) (变为正数)
​

解释:

• 对于正数和 0，arshift 和 rshift 行为一致。

• 对于负数，arshift 保持符号位不变，更能体现 "除以 2" 的数学意义 (向下取整，包括负数)。rshift 会将负数变为正数，通常不符合数学上的除法含义。

应用场景:

• 带符号数的除法优化: 当需要对带符号数进行除以 2 的幂运算时，应使用 arshift 以保持符号不变。

• 处理有符号数: 在需要区分有符号数和无符号数的情况下，arshift 对于有符号数的处理更加合理。

4.4. bit32.rol (x, n) - 循环左移 (Rotate Left)

• 功能: 将整数 x 的所有位向左循环移动 n 位。从左侧移出的位会填充到右侧空出的位。

• 语法: bit32.rol (x, n)

• 参数:

  • x: 要进行位移操作的 32 位整数。

  • n: 位移的位数 (非负整数)。

• 返回值: 循环左移运算的结果。

代码示例:

local a = 0b10000001 -- 129
local result1 = bit32.rol(a, 1)
print(string.format("bit32.rol(%d, 1) = %d (0b%b)", a, result1, result1)) -- bit32.rol(129, 1) = 258 (0b100000010)
local result2 = bit32.rol(a, 4)
print(string.format("bit32.rol(%d, 4) = %d (0b%b)", a, result2, result2)) -- bit32.rol(129, 4) = 2064 (0b100000010000)
local b = 0b11110000000000000000000000000000 -- 高 4 位为 1
local result3 = bit32.rol(b, 4)
print(string.format("bit32.rol(0x%X, 4) = 0x%X (0b%b)", b, result3, result3)) -- bit32.rol(0xF0000000, 4) = 0xF000000F (0b11110000000000000000000000001111)
​

解释:

循环左移不会丢失任何位，移出的位会循环到另一端。