一个后台系统用数字存权限:读是 1,写是 2,删是 4。上线半年都没问题,后来产品加了“导出”权限,值是 8。发布当天,一批原本只有读权限的用户突然能删数据了。开发查了半天,发现判断逻辑写的是 if (perm & READ == READ),由于运算符优先级,它实际被算成了 perm & (READ == READ),结果恒为 0,条件恒为假;另一处写的是 if (perm == READ || perm == READ | WRITE),只枚举了旧组合,新组合直接被放行。
位运算在业务代码里出现得不算多,但一旦出现,通常就在权限、开关、协议、图像、哈希这些“错一位就全错”的地方。这篇不讲教科书式的真值表,而是从权限系统出发,把与、或、异或、取反、移位放回真实代码,讲清它们省了什么,又在哪些地方容易咬人。
现象:权限判断为什么一加新角色就乱
位掩码(bitmask)的思路是,用一个整数的每一位表示一个独立的开关。第 0 位表示读,第 1 位表示写,第 2 位表示删,第 3 位表示导出。一个用户的权限值就是这些位组合起来的结果:只读是 1,读写是 3,读写删是 7,全开是 15。判断某个权限时,用“与”运算取出那一位,看结果是不是非零。
问题在于,很多代码把“取出那一位”写成了“判断整个值等于某个常量”。只读用户的值是 1,读写用户的值是 3,两者都不等于 7,所以“是否拥有读权限”用等值判断就会漏掉大部分合法用户。正确写法是 (perm & READ) != 0,只关心那一位,不关心其他位。加了新权限之后,掩码判断仍然成立,等值判断就得不断补枚举,补漏一个就出事故。
另一个常见事故是优先级。& 的优先级比 == 低,所以 flags & FLAG == 0 会被解析成 flags & (FLAG == 0)。如果 FLAG 是 4,FLAG == 0 是假,也就是 0,整个表达式恒为 0,条件永远不成立。编译器通常会给一个 -Wparentheses 警告,但很多人不看警告,或者用的语言根本不警告。这类 bug 不会崩,只会让权限判断悄悄失效。
为什么等值判断会漏?因为权限值不是“一个角色一个编号”,而是多个开关的组合。只读是 1,读写是 3,读写删是 7,同一个“读”权限出现在多个值里。等值判断只能匹配其中一个值,天然覆盖不全。加一个新权限,组合数翻倍,枚举写法就跟不上了。掩码判断只问“这一位是不是 1”,和别的位无关,所以扩展时不用改旧逻辑。
排查这类问题时,打印二进制比打印十进制有效得多。十进制 7 看不出哪几位是 1,二进制 111 一眼就能对上三个权限,非常直观,也更省事。很多语言都有一行格式化二进制的办法,调试时临时加一行输出,比盯着数据库里的数字猜半天快。权限矩阵测试也值得做:把每个角色和每个操作组合跑一遍,列出允许和拒绝,新增权限时补一行,能提前发现“默认放行”的空档。
场景走查:五个运算符,各自负责什么
与(AND,符号 &)的规则是“两个都为 1 才为 1”。它最常用的场景是“取位”和“清零”:想保留某几位,就用一个掩码去与;想清零某几位,就用掩码取反后再与。或(OR,符号 |)的规则是“有一个为 1 就为 1”,常用场景是“置位”:把某个权限加上去,用或,不会影响已有的位。
异或(XOR,符号 ^)的规则是“不同为 1,相同为 0”。它常用在“切换”和“找不同”:翻转某一位,或者在不使用临时变量的情况下交换两个数。异或还有一个性质,同一个值异或两次会回到原值,所以它能做简单的加解密或校验,但强度很低,不能当安全机制用。
取反(NOT,符号 ~)把每一位翻转。它很少单独使用,通常配合与运算做“清位”:flags & ~MASK 表示把 MASK 对应的位清零,其他位保持不变。注意取反后的值在高位全是 1,如果变量是有符号的,结果会是负数,所以清位时最好用无符号类型,或者先截到目标宽度。
移位(左移 <<、右移 >>)把位整体移动。左移一位相当于乘 2,右移一位相当于除以 2(对非负数成立)。构造掩码时常用 1 << n 表示第 n 位。左移要注意溢出和符号位,右移要注意负数补什么。很多“位运算看着简单却算错”的问题,都出在这两个边界上。
用一个具体值把五个运算串起来。取 a = 0b1010,b = 0b0110:与得到 0b0010,也就是 2;或得到 0b1110,也就是 14;异或得到 0b1100,也就是 12;~a 在 4 位宽度下是 0b0101,也就是 5;a >> 1 是 0b0101,也就是 5。这几个结果在本机 Python 里都能直接复现,后面实测部分会给出完整输出。
异或交换两个数经常被当成炫技。写法是 a ^= b; b ^= a; a ^= b;,不需要临时变量。它在数学上成立,但有两个现实问题:如果 a 和 b 指向同一块内存(比如同一个数组的同一个下标),第一步就会把值清零,后面全错;现代编译器的寄存器分配已经很聪明,省一个临时变量没有实际收益。所以工程上更推荐用临时变量,清晰、安全、编译器同样能优化好。
权限系统里的位掩码
最经典的例子是 Unix 文件权限。读、写、执行三个权限分别对应 4、2、1,三个一组组成八进制的一位。755 表示所有者可读可写可执行,同组用户可读可执行,其他用户可读可执行。拆成二进制就是 111、101、101。要判断“是否有写权限”,就用 2 去与;要加上执行权限,就用 1 去或;要去掉读权限,就用 4 取反后与。
用 Python 验证这套组合,结果都是真实的:
READ, WRITE, EXEC = 4, 2, 1
print(7 & READ) # 4,有读权限
print(5 | WRITE) # 7,加上写权限
print(7 & ~READ) # 3,去掉读权限
print(7 & (READ | EXEC)) # 5,同时有读和执行
print(6 & -6) # 2,取出最低的 1 位
print(bin(0b101101).count('1')) # 4,数 1 的个数
本机 Python 3.15 的实际输出依次是 4、7、3、5、2、4。第三行的 7 与 ~4 得到 3,说明读位被清零,写位和执行位保留。最后两行是两个常用技巧:x & -x 取出最低位的 1,常用于树状数组;bin(x).count('1') 数置位的个数,也就是 popcount。前者依赖补码性质,后者在性能敏感场景会用硬件指令替代。
但位掩码不是万能的权限模型。一个 32 位整数最多表示 32 种权限,超过就要换 64 位或拆成多组;它只能表达“有没有”,不能表达“对哪个对象有”“在什么条件下有”;它也不方便做审计,看到 7 很难一眼说出包含哪些权限。所以真实系统里,位掩码通常只用于粗粒度的开关,细粒度权限还是走角色表或访问控制列表。
同一套思路还能用在配置和功能开关上。一个服务有十几个实验特性,用位掩码存一个整数,读配置时用与运算逐个判断,比存十几个布尔字段省空间,也方便一次性传输。代价是每次加特性都要分配一位,删特性时不能立刻复用那一位,否则老数据会被解释成新含义。位定义要像接口一样版本化,不然回滚和灰度会互相打架。
图像和图形编程里,位掩码更常见。颜色值 0xAARRGGBB 用四个字节分别存透明度、红、绿、蓝,取红色就是与 0x00FF0000 再右移 16 位。图形 API 的混合模式、着色器里的通道操作,都是位运算的变体。这类场景对性能敏感,位运算比逐个字段读写快,也很适合 GPU 的并行执行。但可读性依然是问题,代码里必须写清楚每个掩码对应哪个通道。
实测:优先级、符号位和 JavaScript 的 32 位陷阱
先看那个优先级 bug 在 C 里的实际表现。下面这段代码用 gcc 16.2 编译,开启 -Wall:
int flags = 4, FLAG = 4;
printf("flags & FLAG == 0 -> %d\n", flags & FLAG == 0);
printf("(flags & FLAG) == 0 -> %d\n", (flags & FLAG) == 0);
编译时出现警告:warning: suggest parentheses around comparison in operand of '&' [-Wparentheses]。运行输出是 flags & FLAG == 0 -> 0 和 (flags & FLAG) == 0 -> 0。第二行加了括号,语义正确;第一行虽然这次结果碰巧也是 0,但它的计算过程是 flags & (FLAG == 0),也就是 4 & 0,和“判断 flags 的第 2 位是否为零”完全不是一回事。换一个 flags 值,结果就会分叉。
第二组实验看符号位。同一个 C 程序里:
unsigned char m = 0b1011;
printf("m & 0b0010 = %u\n", m & 0b0010); /* 2 */
printf("~m & 0xFF = %u\n", (unsigned)(~m & 0xFF)); /* 244 */
printf("1<<31 = %d\n", 1 << 31); /* -2147483648 */
printf("1u<<31 = %u\n", 1u << 31); /* 2147483648 */
本机实际输出:m & 0b0010 = 2、~m & 0xFF = 244、1<<31 = -2147483648、1u<<31 = 2147483648。最后两行是重点:有符号的 1 << 31 把 1 移进了符号位,严格说这是未定义行为,本机得到负数只是当前编译器的表现;加 u 变成无符号之后,结果才是稳定的 2147483648。构造高位掩码时,一定用 1u 或 UINT32_C(1),别用裸的 1。
JavaScript 还有一层独有的坑。它的位运算会把操作数转换成 32 位有符号整数,然后再算。所以 1 << 31 在 JS 里是 -2147483648,2147483648 | 0 也是负数。想拿无符号结果,要用 >>> 而不是 >>,或者用 BigInt。很多人从 C 或 Python 抄位运算到前端,忽略了这层转换,标志位一到第 31 位就全乱。
负数右移的行为也值得单独记一笔。C 里有符号右移是实现定义,本机 gcc 对 -1 >> 1 得到 -1,因为算术右移补符号位 1,怎么移都还是全 1。换成无符号数再右移,高位补 0,结果才是“除以 2 向下取整”。Java 用 >> 做算术右移、>>> 做逻辑右移,Python 的 >> 对负数也是向下取整,不会补成一个大正数。跨语言比较右移结果时,先把负数转成无符号,能省掉很多困惑。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 权限判断永远为假或永远为真 | & 与 == 的优先级弄错 | 给位运算加括号,打开编译器的括号警告 |
| 加了新权限后旧判断失效 | 用等值比较枚举组合,没有用掩码取位 | 把 perm == X 改成 (perm & X) != 0 |
| 第 31 位标志变成负数 | 有符号 1 左移 31 位,进入符号位 | 改用无符号字面量或 64 位类型 |
| 负数右移结果和预期不同 | 算术右移补 1,逻辑右移补 0 | 确认语言规则,必要时转无符号再移 |
| 组合标志位时丢了其他位 | 用加号拼接,遇到重复位产生进位 | 改用按位或,检查是否重复定义位 |
| 清位后误删了别的权限 | 掩码写错,或用了 &= 而不是 &= ~mask | 打印掩码的二进制,逐位核对 |
| 前端算出的标志位是负数 | JavaScript 位运算强制转 32 位有符号 | 改用 >>> 或 BigInt |
| 协议字段解析总是错位 | 用位域结构体,布局由编译器决定 | 改成显式移位和掩码,按规范逐位取 |
边界与代价
位运算最大的代价是可读性。一个 0x5A3 里到底开了哪些开关,不查表看不出来;一个 perm & 0x18 判断了哪两项,也得对着常量表才知道。这种紧凑在存储和传输上是优势,在人读代码时是负担。工程上的做法是给每一位起名字,用常量或枚举代替魔法数字,把位定义集中在一个文件里,改的时候只改一处,并且写清楚“第几位是什么,什么时候可以复用”。
第二个代价是位宽上限。32 位只能放 32 个开关,64 位 64 个,超过就得拆成多个字段或换成集合类型。很多系统一开始用 32 位,功能加着加着就不够,最后不得不迁移存储和接口。设计时如果预计开关会持续增加,直接用 64 位或独立布尔字段,比事后迁移便宜。
第三个代价是跨语言和跨平台的差异。C 的有符号左移、位域布局、类型宽度都可能因编译器而异;JavaScript 强制 32 位;Python 整数没有固定宽度,取反会得到无限位宽的负数;Java 的 >>> 是无符号右移,C 没有对应的运算符。把一段位运算从一种语言搬到另一种语言,不能只看符号长得一样,要确认语义。
第四个代价是错误难以发现。位运算不抛异常,不越界检查,错一位往往只是结果不对,不会立刻崩溃。权限判断错了可能表现为“某些用户能看到不该看的数据”,而不是报错;协议解析错了可能表现为“偶尔丢包”或“字段值跳变”。这类问题要靠单元测试覆盖所有位组合,尤其是边界位和高位。
第五个代价是安全。权限位掩码一旦判断写反,默认行为可能是“放行”而不是“拒绝”。安全相关的判断要默认拒绝,只有明确命中白名单才放行;掩码比较要用“非零”而不是“等于某个值”;新增权限时,要检查所有旧的判断路径,避免出现“未定义即为允许”的空档。上线前用不同角色跑一遍权限矩阵,比事后审计有效得多。
还有一个容易被忽略的点:位运算和字节序是两件不同的事。位运算在寄存器内部进行,和内存里字节怎么排无关;但一旦把结果写进多字节字段发给别的机器,就要考虑字节序。位掩码定义的是“第几位”,传输定义的是“哪个字节在前”,两者不要混着排查。
如果业务里的权限关系越来越复杂,位掩码可能不是最合适的工具。角色模型(RBAC)用“用户属于角色、角色拥有权限”的两层表,扩展新权限只要加一行记录,不用改代码里的位定义;访问控制列表(ACL)可以精确到每个资源、每个用户,表达能力强,代价是查询和存储更重。位掩码适合“开关少、判断频繁、不需要细粒度”的场景,不适合“权限经常变、需要审计、需要按对象授权”的场景。选型时先看业务会不会长,再决定用哪种。
当天能自己验证的练习
- 定义读、写、执行、导出四个位,值分别是 1、2、4、8,写函数判断“是否拥有某个权限”,再用不同组合测试,确认加新位不会影响旧判断。
- 故意写一个
flags & FLAG == 0的判断,用 gcc-Wall编译,看警告;再加上括号,比较两种写法的输出。 - 用 Python 枚举 0 到 15 的所有权限组合,打印每个值包含哪些位,观察“或”组合和“与”判断的对应关系。
- 在 Node 里计算
1 << 31、1 << 31 >>> 0和2147483648 | 0,记录结果,再用BigInt算一遍对比。 - 用
x & -x写一个函数取出最低位的 1,再用x & (x - 1)清除最低位的 1,循环统计一个数的二进制里有多少个 1。
小结与下一篇
位运算用五个运算符处理“某一位”:与用来取位和清位,或用来置位,异或用来翻转和比较,取反配合与做清位,移位用来构造掩码。权限系统里要判断“有没有”,不要判断“等不等于”;要注意优先级、符号位、位宽和跨语言差异。位掩码省空间、快,但可读性差、上限固定、错误不吭声,安全相关的判断要默认拒绝。
位运算关心的是“某一位”,但数据在传输和存储过程中还可能整段出错:一位翻转、一段字节被改写、文件下载不完整。下一篇讲下载完的文件怎么知道没坏:校验与奇偶,看奇偶校验、CRC 和哈希是怎么发现这些错误的。