去年冬天,一个内容社区的后台改了一版删除权限。需求只有一句话:「仅管理员或作者本人可以删除帖子」。改动只碰了一个 if,评审十分钟通过,测试环境点了两下也正常。上线第二天,运营在审计日志里看到一个陌生账号删掉了别人三天前发的帖子。
出问题的判断长这样,括号和运算符都在该在的位置,所以看起来毫无破绽:
if (isAdmin || isOwner === false) {
deletePost();
}
写的人想的是「不是管理员,那就得是作者本人」,落到代码里变成了「或者这个用户不是作者」。第二个子句对普通用户恒为真,第一个子句等于没写,所有登录用户都能删。测试环境没暴露,是因为测试账号恰好是管理员,短路求值让后半句从没执行过。
这不是不熟悉语法,是把复合命题的真假条件记反了,代码只是忠实地执行。这篇依次讲:命题是什么,五个联结词的真值,真值表怎么列,德摩根律怎么改写条件,以及 SQL 的 NULL 为什么让「取反」失效。
命题只回答一件事:真,还是假
命题(proposition)是一句能判断真假的话,取值只有真、假,没有中间地带。「今天天气不错」不是命题,因为「不错」没有标准;「1 加 1 等于 3」是命题,值为假。
代码里几乎所有布尔表达式都是命题。user in admins 是原子命题(atom),它已经拆不动,只能整体判真假;is_admin or is_owner 是复合命题,由原子命题加联结词拼成。一个 if 的本质,就是拿一个复合命题决定走哪条分支。所以「条件写反」不是代码问题,是命题问题。
为什么值得专门学?因为写条件时用的是自然语言直觉,而两者并不整齐对应。中文的「或」常是二选一,「除非」的否定方向要靠猜,「只有 A 才 B」在口语里和「如果 A 就 B」几乎同义,在逻辑里方向相反。真值表的作用就是把这些直觉赶出去:所有取值组合排成一张表,一行一行算。
先用三个账号把开头那段跑一遍:u1 是管理员,u2 是 p2 的作者,u3 什么都不是;p1 属于 u2,p2 属于 u1。
admins = {"u1"}
posts = {"p1": "u2", "p2": "u1"}
def can_delete_buggy(user, post_id):
is_admin = user in admins
is_owner = posts[post_id] == user
return is_admin or is_owner == False
def can_delete_ok(user, post_id):
is_admin = user in admins
is_owner = posts[post_id] == user
return is_admin or is_owner
for user in ("u1", "u2", "u3"):
for post_id in ("p1", "p2"):
print(user, post_id, "buggy:", can_delete_buggy(user, post_id),
"ok:", can_delete_ok(user, post_id))
本机 Python 3.15 的输出:
u1 p1 buggy: True ok: True
u1 p2 buggy: True ok: True
u2 p1 buggy: False ok: True
u2 p2 buggy: True ok: False
u3 p1 buggy: True ok: False
u3 p2 buggy: True ok: False
结果里 u3 是路人,两篇都能删;u2 是 p2 的作者,反而删不了自己的帖子。出错版本不是「多放行几个人」,而是把「作者」整个翻转:作者不能删,非作者能删。posts[post_id] == user 本身已是布尔命题,再接一个 == False,等于对同一判断又取了一次反。
五个联结词,只有蕴含会反直觉
联结词(connective)就是把真假值重新组合起来的运算。能把命题拼成新命题的基本运算一共五个,没有第六个。
否定 ¬P,读作「非 P」:真变假,假变真。代码里 Python 写 not,JavaScript 写 !。它是一元的,只需要一个命题。
合取 P ∧ Q,读作「P 且 Q」:只有两边都真才真。Python 是 and,JavaScript 是 &&。它不要求两个命题内容相关,「2 是偶数且北京在下雨」照样合法,只是值为假。
析取 P ∨ Q,读作「P 或 Q」:有一个真就真,两个都假才假,这叫相容或。自然语言的「或」经常是排斥或,「配米饭或面条」通常不会两样都上。排斥或要写成 (P ∨ Q) ∧ ¬(P ∧ Q),代码里是 p != q,位运算里是 p ^ q。
蕴含 P ⇒ Q,读作「如果 P 那么 Q」。P 叫前件,Q 叫后件。它是五个里最反直觉的:只有「P 真且 Q 假」这一种情况为假,其余三种全为真。
等价 P ⇔ Q,读作「P 当且仅当 Q」:同真同假。它等于 (P ⇒ Q) ∧ (Q ⇒ P),即两条蕴含同时成立。代码里对应布尔值的相等比较,JavaScript 用 === 比 == 稳,后者会做类型转换。
| P | Q | ¬P | P ∧ Q | P ∨ Q | P ⇒ Q | P ⇔ Q |
|---|---|---|---|---|---|---|
| 真 | 真 | 假 | 真 | 真 | 真 | 真 |
| 真 | 假 | 假 | 假 | 真 | 假 | 假 |
| 假 | 真 | 真 | 假 | 真 | 真 | 假 |
| 假 | 假 | 真 | 假 | 假 | 真 | 真 |
现在解释蕴含为什么前件为假时整体为真。用「下雨则地湿」:设 P 是「今天下雨」,Q 是「地面是湿的」,整句当成一个承诺,只要下雨就保证地湿。
下了雨地也湿:承诺兑现,为真。下了雨地却是干的:承诺被违背,为假,这是唯一「说谎」的情况。没下雨但地湿了(洒水车刚过):没人承诺不下雨就不能湿,承诺没被违背,为真。没下雨地也干:同样没违背,为真。
所以蕴含只管一件事:前件成立时后件必须成立;前件不成立,整句自动为真,这叫空真(vacuous truth)。这不是文字游戏,而是让蕴含能被当成可计算运算的代价:如果前件为假时蕴含「没有值」,命题逻辑就不再是二值的,真值表也做不成。
落到代码里,P ⇒ Q 不是能直接写出的表达式,它对应「用一个分支来保证」,等价写法是 not P or Q。所以参数校验里这两种写法说的是同一件事:
if has_token and not is_valid(token):
reject()
if not has_token or is_valid(token):
pass()
前者写的是蕴含的否定,后者写的是蕴含本身。选哪个取决于想让合法路径出现在 then 还是 else,取舍是可读性,不是正确性。
蕴含最常见的两个误读,是把 P ⇒ Q 当成逆命题 Q ⇒ P,或当成否命题 ¬P ⇒ ¬Q。两者都不等价,唯一等价的是逆否命题 ¬Q ⇒ ¬P。
逆命题:方向反过来
「地湿则下雨」,洒水车一过就证伪了。代码里的典型症状是把「有权限才能操作」写成「操作了就有权限」,前者是校验,后者是事后推断。
否命题:两边同时取反
「不下雨则地不湿」,洒水车同样能证伪。原命题的否定是「P 且非 Q」,不是另一条蕴含,这一点在写错误提示时经常被搞混。
顺带记一句:¬(P ⇒ Q) 等价于 P ∧ ¬Q,所以排查「条件没生效」总是从「前件为真而后件为假」入手。
真值表怎么列:2 的 n 次方行
规则一句话:n 个原子命题,列 2n 行,每行一种取值组合,每个复合子表达式各占一列。三个变量 8 行,四个 16 行,十个 1024 行。行数只和原子命题个数有关,和表达式写得多长无关,这一点后面会变成一道硬墙。
列的写法建议按二进制计数排:从全假开始,逐行加一,最后一行全真。这样既不会漏也不会重,手写八行容易错一行,写个循环最稳。下面用 Python 穷举三个变量的八种组合,验证德摩根律的三变量形式。
import itertools
rows = []
for p, q, r in itertools.product((True, False), repeat=3):
left = not (p and q and r)
right = (not p) or (not q) or (not r)
rows.append((p, q, r, left, right, left == right))
for row in rows:
print(int(row[0]), int(row[1]), int(row[2]), int(row[3]), int(row[4]), row[5], sep=" ")
print("all equal:", all(row[5] for row in rows))
输出前三列是三个变量的取值,第四列是「并非三个都真」,第五列是「至少一个不真」,最后一列是两者是否一致:
1 1 1 0 0 True
1 1 0 1 1 True
1 0 1 1 1 True
1 0 0 1 1 True
0 1 1 1 1 True
0 1 0 1 1 True
0 0 1 1 1 True
0 0 0 1 1 True
all equal: True
八行全一致,所以两个表达式等价。等值式的意思不是「看起来像」,而是「所有取值组合下真值都一样」,这句话可验证,也是真值表存在的全部理由。
它真正的好处是把「凭感觉」变成「可判定」:给定两个表达式,穷举一定能得到确定答案,不会悬而未决。代价是指数级的行数,所以只适合验证短表达式。工程上的条件很少超过六个,26 等于 64 行,毫秒级就能跑完。
用法很具体:改完条件判断,把旧、新表达式都写成布尔函数,穷举参数比较返回值。但边界很清楚:穷举只能证明新旧一致,不能证明旧代码符合需求;需求一开始就读错,两张表会非常一致地一起错。
德摩根律:把否定推过括号
德摩根律(De Morgan's laws)只有两条,却是几乎所有条件改写的底座:
¬(P ∧ Q) ≡ ¬P ∨ ¬Q
¬(P ∨ Q) ≡ ¬P ∧ ¬Q
一句话记:否定穿过括号,且变或,或变且,括号里每一项都要被否定。直觉版本更顺口,「不是(既要有票又要成年)」等于「没票,或者未成年」。
工程上值得单独记住,是因为权限、校验、过滤器三类代码天生带否定:它们的共同点是「排除某些情况」,而排除就是用否定写的。把否定推到最里层,每个子条件单独可读;把否定留在最外层,括号一多就没人看得清作用范围。
但改写不是免费的。否定推到底,语义从「允许某一类」变成「排除其他所有类」,读的人要在脑子里做一次补集。所以落地时选更接近需求原句的那一版:需求说「管理员或作者可删」,就写 is_admin or is_owner,不要为了省一个否定改成「非(非管理员且非作者)」。
括号什么时候必须加,不能靠记忆,只能靠一次实跑。Python 里 not 的优先级低于比较运算符,所以 not a == b 实际是 not (a == b);而 not a or b 是 (not a) or b。两条规则方向相反,混着记一定出错。JavaScript 里 ! 优先级最高,&& 高于 ||,所以 a || b && c 是 a || (b && c)。
a, b, c = True, False, False
print("a or b and c =", a or b and c)
print("(a or b) and c =", (a or b) and c)
print('not "a" == "b" =', not "a" == "b")
print('(not "a") == "b" =', (not "a") == "b")
a or b and c = True
(a or b) and c = False
not "a" == "b" = True
(not "a") == "b" = False
四行里有两对结果不同。第一对说明 and 先结合;第二对说明 not 先算比较再取反,而不是先把字符串取反再比较。这类差异不会报错,只会在某个边界数据上悄悄走相反分支,所以「顺手加括号」成本最低。
短路求值:省下的计算,和藏起来的行为
短路求值(short-circuit evaluation)是语言给的优化:and 左边为假、or 左边为真时,右边不再计算。从命题逻辑看完全合法,因为合取有一个假就假,析取有一个真就真。但「不影响结果」不等于「不影响程序」:右边可能带着函数调用、日志、数据库写入。
def ping(msg):
print(" side effect:", msg)
return True
print("False and ping(...) =", False and ping("A"))
print("True or ping(...) =", True or ping("B"))
print("True and ping(...) =", True and ping("C"))
print("False or ping(...) =", False or ping("D"))
False and ping(...) = False
True or ping(...) = True
side effect: C
True and ping(...) = True
side effect: D
False or ping(...) = True
前两行没有副作用输出,后两行有。A 和 B 两次调用被直接跳过,函数里的打印一次都没发生。如果那是发邮件、扣库存、写审计日志,这段代码就等于「有时执行有时不执行」,而且不报错。
第一,不要在带副作用的调用上依赖短路。今天 False and send_email() 是永久不执行,明天左边换成变量就变成偶尔执行;反过来写成 send_email() and False,副作用一定发生,返回值却永远是假,谁看返回值谁被误导。
第二,用短路做默认值 x or default 很常见,代价是把「假值」和「缺失」混成一类。0、空字符串、空列表在 Python 里都是假值,全会被替换掉。判断「有没有填」时这是 bug,判断「名字为空就用匿名」时这是特性,差别只在语义。
第三,and 和 or 返回的是操作数本身,不是布尔值。Python 里 1 and "x" 返回字符串,None or 0 返回数字 0,JavaScript 的 && 与 || 也一样。「这个字段怎么突然变成字符串」这类问题,源头经常是一个看起来只做判断的表达式被当成了取值表达式。
print('bool(0) =', bool(0), '| bool("") =', bool(""), '| bool([]) =', bool([]), '| bool(None) =', bool(None))
print('0 or "default" =', 0 or "default")
print('None or 0 =', None or 0)
print('1 and "x" =', 1 and "x")
bool(0) = False | bool("") = False | bool([]) = False | bool(None) = False
0 or "default" = default
None or 0 = 0
1 and "x" = x
输出里 None or 0 返回 0 而不是某个默认值,因为 0 是假值,表达式走到了右边。想表达「没有值就给 0」,正确写法是显式的 is None 判断或空值合并运算符,而不是靠 or 猜。
三态逻辑:SQL 的 NULL 让取反失效
到现在为止命题只有真和假。真实系统里经常有第三个值:不知道。SQL 的 NULL 就是它,含义是「没有值」,不是 0,也不是空字符串。它和任何值比较结果都是 NULL,包括和另一个 NULL 比较:NULL = NULL 的结果不是真,是 NULL。
而 WHERE 只保留判定为真的行,NULL 既不是真也不是假,直接被丢掉。于是「取反」在 SQL 里不再是补集:筛出 A 的行加上筛出「非 A」的行,加起来可能少于总行数。跑一遍就能看到。
import sqlite3
con = sqlite3.connect(":memory:")
con.execute("create table posts (id integer, status text)")
con.executemany("insert into posts values (?, ?)",
[(1, "active"), (2, None), (3, "blocked"), (4, "active")])
for q in [
"select count(*) from posts where status = 'active'",
"select count(*) from posts where status != 'active'",
"select count(*) from posts where not (status = 'active')",
"select count(*) from posts where status is null",
]:
print(q.split("where ")[1].ljust(30), con.execute(q).fetchone()[0])
status = 'active' 2
status != 'active' 1
not (status = 'active') 1
status is null 1
表里四行:两行 active,一行 blocked,一行 NULL。前两个查询各选出 2 行和 1 行,加起来 3 行,第 2 行(status 为 NULL)哪边都不算,只有第四行单独查 NULL 才拿到它。NOT 不能把 unknown 翻成真,只能继续留在 unknown。
正确做法有三条。一是建表时消灭第三态:能加 NOT NULL 就加约束,能给默认值就给。二是查询里显式处理:where status is null or status != 'active',或用 coalesce(status, '') 把 NULL 折成哨兵值。三是用 PostgreSQL 的 is distinct from,它把 NULL 当普通值比较,对 NULL 行返回真。
要注意三值逻辑不是布尔代数。排中律 P ∨ ¬P 在这里不成立:unknown 取反还是 unknown,析取也是 unknown。德摩根律在 Kleene 三值逻辑里仍然成立,但排中律和矛盾律失效,所以布尔化简的很多步骤不能直接搬过来,「取反再取反」的自信在三值逻辑里站不住。
JavaScript 的 undefined 和 Python 的 None 是另一种麻烦:值只有两个布尔映射,真值判断却把很多不同的值压成假。0、""、NaN、空容器在两种语言里都是假值。于是 if (userInput) 会把用户填的 0 当成没填。这不是三值逻辑,是把多种语义压成一个判断,后果一样:合法数据被当成缺失。
结论很朴素:能比较就别用真值判断。判断「有没有」用 is None、=== undefined、??;判断「等不等于」用显式相等;只有语义真是「真不真」时,才交给 if 的真值规则。
一张现象对照表
这些现象的原因各不相同,但都能回到命题与真值这一层。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 普通用户能删别人的帖子 | 条件写成 is_owner === false,非作者被当成满足条件 | 把每个子条件的布尔值单独打印,和需求原句逐项对照 |
| 作者本人反而删不了自己的帖子 | 同一个翻转错误的反向症状 | 用管理员、作者、路人三种账号各跑一遍 |
| 管理员也被拒绝 | 把 !(A || B) 写成 !A || !B,否定没有分配到每一项 | 穷举四个取值组合,对照德摩根律 |
| 某个分支的日志从来没出现 | 短路求值跳过了带副作用的那一侧 | 在被跳过的调用里加一行打印,确认是否执行 |
| 用户填了 0 却提示「未填写」 | 用真值判断「有没有值」,0 被归入假值 | 改成 is None 或 === undefined |
| 列表比总数少一条 | NULL 参与比较得到 unknown,被 WHERE 丢弃 | 单独统计 is null 的行数,和两个方向相加核对 |
| 同一条件在两种语言结果不同 | 一个返回布尔值,一个返回操作数;或优先级不同 | 打印表达式返回值本身,而不是只看 if 走了哪边 |
| 加了两个条件后漏测 | 手写组合表漏行,行数按 2 的 n 次方增长 | 先数原子命题个数,再用循环生成全部组合 |
边界与代价
第一,真值表会组合爆炸。n 个原子命题就是 2n 行,20 个条件已经超过一百万行。它只能当「小表达式验证器」,不能当设计工具。条件超过六七个时,正确做法是把条件拆成有名字的中间变量,每一层单独验证。
第二,真值表验证表达式内部的一致性,不验证需求。需求被读错,新旧表达式会一致地一起错,表格一片绿,线上照样出事。列表之前先把需求原句拆成原子命题,确认每个变量对应哪半句。开头那个 bug 的真正修复点,是「is_owner 已经是命题」。
第三,短路求值有可读性代价。条件里藏函数调用,执行顺序就成了隐式契约;后来的人调整条件顺序,或者把 and 改成先算另一边,行为就变,测试未必覆盖得到。判断标准很简单:右边有没有副作用,有就别放进条件,先算出来存成变量。
第四,三值逻辑不是布尔代数。它的真值表是 3×3 不是 2×2,排中律失效,部分化简规则失效,不同数据库在聚合、去重、唯一索引上对 NULL 的处理还有差异。凡是要对 NULL 取反,都应该显式写出来。
第五,自然语言到逻辑的翻译有损耗。中文「或」常是排斥或,「除非」可能翻成 ¬P ⇒ ¬Q 也可能翻成 Q ⇒ P;「只有 A 才 B」是 B ⇒ A,方向和直觉相反。写条件前把原句抄进注释。
小结与练习
主线压成三句:命题只有真假两个值,五个联结词的真值由真值表定死,蕴含只在前件真、后件假时为假;真值表穷举 2n 种组合,用来验证等值式而不是背公式;德摩根律把否定推进括号,是条件改写的底座,而 SQL 的 NULL 让取反从补集退化成一次过滤。
当天可以自己验证的练习:
- 把开头那段
can_delete_buggy和can_delete_ok都跑一遍,用三个账号、两篇文章打印成矩阵,找出两版结果不同的所有格子,并解释每个差异来自哪个子条件的翻转。 - 用
itertools.product生成三个变量的 8 行真值表,验证not (p and q and r)与(not p) or (not q) or (not r)等价;再把中间的or改成and,看有几行不一致。 - 写一个带
print的函数,分别放进False and f()、True or f()、True and f()、False or f(),记录哪几次真的执行;再把f()挪到左边重跑一次。 - 在内存 SQLite 里建一张四行的表,其中一行状态为 NULL,分别统计
status = 'active'、status != 'active'、not (status = 'active')、status is null的行数,验证前两个数字之和小于总行数。 - 把
if not (a and b)改写成德摩根形式,用四组取值确认等价;再写一版漏掉括号的not a and b,找出两者结果不同的取值组合,说明它对应什么样的真实数据。
下一篇讲布尔代数与位运算。这一篇里的真和假会换成 0 和 1,and、or、not 换成 &、|、~,德摩根律原样保留。再往后一步,位运算把这些 0 和 1 压进同一个整数的不同位,一个整数就能表示十种权限。逻辑能从纸上搬到寄存器上,靠的正是这两步:先承认真假可以当数字算,再承认一排真假可以当一个数字存。