有一次上线满减活动,运营配置「无门槛券」,门槛填的是 0。代码里用了一行很常见的默认值写法:

const threshold = config.threshold || 99;

结果 0 被视为「没配置」,全部换成了 99。用户领了券发现用不了,客服电话被打爆。这行代码单看挑不出毛病,问题在于 || 判断的是「真假」,不是「有没有值」。

这篇讲什么:条件判断里那些会自己发生的类型转换、== 和 === 到底差在哪、逻辑运算符为什么不返回布尔值,以及 ?? 和 ?. 这两个现代写法什么时候该用。读完你能做到:写默认值、判空、取深层属性时不再靠运气;看到别人写的 if (value) 能立刻判断它在什么情况下会走进去。

if 里的值会被悄悄转成布尔

if (x)、&&、||、三元表达式,这些位置上的值都会被当成布尔来用。规则很简单:只有下面这一小撮是假值(falsy),其他全是真值。

八个假值,记牢就够用
false
0
-0
0n
""
null
undefined
NaN

容易翻车的恰恰是那些「看着像空、其实是真」的值:

if ("0")      { console.log("进来了"); }  // 打印:进来了
if ("false")  { console.log("进来了"); }  // 打印:进来了
if ([])       { console.log("进来了"); }  // 打印:进来了
if ({})       { console.log("进来了"); }  // 打印:进来了
if (" ")      { console.log("进来了"); }  // 打印:进来了,空格字符串也是真值

表单里最常见。input.value 永远是字符串,用户输入 0,值是 "0",是真值;用户什么都没填,值是 "",是假值。所以「有没有填」要看空字符串,而不是看真假:

const raw = input.value.trim();
if (raw === "") {
  showError("请填写数量");
  return;
}
const quantity = Number(raw);   // 通过校验后再转

数组和对象的判断也一样。空数组 [] 是真值,所以 if (list) 永远是 true(只要它不是 null),要看长度写 if (list.length) 或 if (list.length > 0)。对象要看有没有某个字段,用 Object.keys(obj).length 或者干脆判字段本身。

这里有个容易混淆的点:真假判断不是「有没有值」。0 是假值但它是合法数量,空字符串是假值但可能只是用户没填,空数组是真值但它确实没有数据。先想清楚你要问的是「有没有填」「是不是空」还是「是不是 null」,再决定用哪个判断。

if (value) 的语义是「这个值在布尔上下文里算真」,不是「这个变量存在」。变量没声明会直接 ReferenceError,跟真假无关;变量声明了但值是 undefined,才会走到 false 分支。这两个问题要用不同手段:前者靠作用域或 typeof 检查,后者靠 value === undefined。

== 和 ===:只在一种场景用 ==

两者的区别是:=== 比较时不做类型转换,类型不同直接不相等;== 会先转换再比。转换规则不算复杂,但组合起来足够让人记不住:

表达式结果过程
1 == "1"true字符串转数字
0 == ""true空字符串转成 0
0 == falsetrue布尔转数字
"" == falsetrue两边都转成 0
null == undefinedtrue语言规定的特例
null == 0falsenull 只和 undefined 相等
[] == falsetrue数组转成空字符串,再转成 0
"0" == falsetrue两边都转成 0

看到这些组合,你大概能理解为啥团队规范里基本都是一刀切「用 ===」。我自己也只有一个例外会用 ==:判断某个值是不是「空」,也就是 null 或 undefined 都算:

if (value == null) {
  // 同时覆盖 null 和 undefined
}
// 等价于 if (value === null || value === undefined),但短得多

这个写法是语言层面明确保证的特例,不会有其他值混进来,可以放心用。除此之外,尤其比较数字和字符串时,一律 ===。接口字段是字符串就先把类型转对再比,别让 == 替你猜。

但要记住 == null 只覆盖 null 和 undefined。接口如果返回空字符串、0 或者 NaN,它都不算「空」,会照常往下走。所以判空之前先确认接口契约:字段缺失到底是 null、"" 还是没这个 key,别用一套判断套所有接口。

还有一个坑是 NaN:NaN === NaN 是 false,NaN == NaN 也是 false。判断它只能靠 Number.isNaN(),这不是严格相等的问题,是 NaN 的定义就这样。

相似的还有正零和负零。=== 分不出它们,Object.is 可以:

Object.is(NaN, NaN)   // true
Object.is(0, -0)      // false
0 === -0              // true
1 / -0                // -Infinity

业务里负零很少见,但计算折扣、取反、乘以负数时可能算出来。真在意就用 Object.is 判断,或者在结果进展示层之前统一归一化成 0。

逻辑运算符返回的不是布尔值

很多人以为 a && b 返回 true 或 false。实际上它返回的是「决定结果的那个操作数」:&& 遇到第一个假值就返回它,全真则返回最后一个;|| 遇到第一个真值就返回它,全假则返回最后一个。所以:

"abc" && 123        // 123
"" && 123           // "",返回空字符串,不是 false
0 || "默认值"         // "默认值"
"已填" || "默认值"     // "已填"
null && 123          // null

这套「返回操作数」的规则还延伸出三个赋值运算符,写起来短,坑和 || 一样:

let a = 0;
a ||= 10;      // 10,0 被当成没配置
let b = 0;
b ??= 10;      // 0,保留合法值
let c = null;
c ??= 10;      // 10

let user = null;
user &&= user.name;  // null,右边不会执行

最后一行能跑,是因为 && 短路了;但读起来要在脑子里转一下,团队里不如老老实实写 if。

这个差别在写渲染时最容易出事。React 里写 count && <span>共 {count} 件</span>,count 为 0 时返回的是数字 0,React 会把它当内容渲染出来,页面上出现一个孤零零的 0。想表达「有才显示」,写成 count > 0 && ...,或者用三元表达式。

这个特性被大量用来写「存在才渲染」和「兜底」,但两边都有代价。先说渲染:

// 想把「销量 0 件」显示出来
const order = { sales: 0 };
const text = order.sales && ("销量 " + order.sales + " 件");
console.log(text);   // 0

// 期望显示「销量 0 件」,实际只得到一个孤零零的 0

这不是语法错误,是逻辑运算符的返回值被直接拼进了界面。要判断「有没有这个字段」而不是「这个字段真不真」,用三元表达式更稳:

const text = order.sales != null
  ? "销量 " + order.sales + " 件"
  : "销量未知";

再说兜底。开头那个事故就是 || 的典型误用:它分不清「0」「""」「false」和「没值」。如果业务上 0 是合法配置,就必须用空值合并:

?? 和 ?.:专门处理「没有值」

??(空值合并,nullish coalescing)只在左边是 null 或 undefined 时才用右边。0、空字符串、false 都算「有值」,会被保留:

const threshold = config.threshold ?? 99;   // 传 0 就是 0
const count = 0 ?? 10;                      // 0
const name = "" ?? "匿名";                   // ""
const empty = null ?? "匿名";                // "匿名"

一句话选型:默认值语义用 ??,明确要「过滤掉所有假值」才用 ||。前者更常见。

但 ?? 也有覆盖不到的地方:它只认 null 和 undefined,所以会保留空字符串。用户把输入框清空得到 "",这时 value ?? "默认" 不会给默认值;如果业务上「空串也算没填」,还是得自己写 value === "" 判断。

?.(可选链)解决的是另一个日常麻烦:取深层属性前层层判空。

// 老写法
const city = user && user.address && user.address.city;

// 现在的写法
const city = user?.address?.city;   // 任何一环是 null/undefined 就返回 undefined

// 调用方法也适用
const upper = name?.toUpperCase();  // name 为空时返回 undefined,不会报错
obj?.method?.();                    // 方法存在才调用

可选链还能用在方括号取值和函数调用上,列表和回调里很常见:

const first = list?.[0];
const value = obj?.[key];
const result = callback?.();

有一个它救不了的场景:变量本身没声明。下面这行不是返回 undefined,而是直接 ReferenceError,因为标识符解析在可选链之前就失败了:

console.log(notDeclared?.name);  // ReferenceError: notDeclared is not defined

另外,?. 只防 null 和 undefined。字段是空字符串、0、false 时它照常往下走,后面该出错还是出错。它解决的是「这一层可能不存在」,不是「这个值可能不合法」。

几个要记住的限制:

只能读,不能赋值

user?.name = "张三" 是语法错误。可选链只在读取路径上生效,写入要老老实实先判断。

别和 ?? 混着不加括号

a ?? b || c 会直接报语法错误,因为规范要求这两种运算符混用时必须加括号。写成 (a ?? b) || c 或 a ?? (b || c),顺便逼你想清楚优先级。

短路是真的短路

user?.address?.city 里 user 为空时,后面的 address 根本不会被读取。所以别把有副作用的调用放进可选链后面,读代码的人看不出它会不会执行。

可选链不是「到处都加就安全」。如果 address 按业务约定必须存在,加了 ?. 反而会把数据问题藏起来,页面显示空白却没人发现接口少返回了字段。该报错的地方让它报错,比静默变 undefined 好排查。

优先级和那些「少写一行」的写法

运算符优先级不需要背全表,但有几处必须留心,因为它们不会报错,只会算错:

// 想判断 a 是否等于 b 或 c
if (a === b || c) { }        // 错:c 被当成条件,只要 c 是真值就进
if (a === b || a === c) { }  // 对

// 三元嵌套,读起来非常费劲
const label = status === 1 ? "待付款" : status === 2 ? "已付款" : "已完成";
// 状态超过三个,换成对象映射或 switch 更好维护

// 一元加号转数字,简短但容易看漏
const n = +value;            // 等价于 Number(value)
// 团队里如果不统一,读代码的人会愣一下,不如写 Number()

还有 ++ 和 --:i++ 先取值再加,++i 先加再取值。写在单独一行时没区别,一旦混进表达式就容易出错,比如 arr[i++] = value。这种写法在老代码里很常见,新代码里没必要省这一行。

优先级再补一组,代码评审里很常见:

const a = 1, b = 0, c = 2;
a || b && c      // 1,先算 b && c
(a || b) && c    // 2

let x, y;
x = y = 2;       // 2,赋值从右往左

记不住就加括号。括号不丢人,猜错了才丢人。

一元加号也是同类问题。它等价于 Number(),结果包括 +null 是 0、+"" 是 0、+undefined 是 NaN。写起来是短,但读代码的人容易漏看那个加号,金额转换上尤其别用。

完整场景走查:结算页选最优优惠券

需求:结算页拿到订单金额和可用券列表,前端先筛一遍,展示「已减 15 元,应付 73 元」,用户提交时只传券 ID,金额由后端复核。金额单位是分,整数。

GET /api/coupons/available?orderCents=8800
{
  "coupons": [
    { "id": "C20261106001", "threshold": 0, "discount": 1500, "newUserOnly": false, "endAt": "2026-11-11 23:59:59" },
    { "id": "C20261106002", "threshold": 9900, "discount": 1000, "newUserOnly": true, "endAt": "2026-11-11 23:59:59" },
    { "id": "C20261106003", "threshold": 20000, "discount": 3000, "newUserOnly": false, "endAt": "2026-11-11 23:59:59" }
  ]
}

88 元订单,应该能用第一张无门槛券,减 15 元,应付 73 元。第一版这样写:

function usable(coupon, orderCents, isNewUser) {
  const threshold = coupon.threshold || 9900;
  if (orderCents < threshold) return false;
  if (coupon.newUserOnly && !isNewUser) return false;
  const end = new Date(coupon.endAt);
  if (end < new Date()) return false;
  return true;
}

function pickBest(coupons, orderCents, isNewUser) {
  return coupons
    .filter(c => usable(c, orderCents, isNewUser))
    .sort((a, b) => b.discount - a.discount)[0];
}

上线后结算页直接白屏,控制台是 Cannot read properties of undefined (reading 'discount'):threshold 为 0 的券被 || 换成了 9900,88 元订单不满足;第二张门槛也是 9900;第三张要 200 元。三张全被筛掉,pickBest 返回 undefined,页面读 .discount 就崩了。

紧急补了个 best?.discount ?? 0,页面不崩了,但用户发现券没减,客服一上午收到十几条「券没扣」。第二个问题在 iOS 上:new Date("2026-11-11 23:59:59") 这种带空格的格式不是标准格式,Safari 上会得到 Invalid Date,比较结果永远是 false。表现出来就是券到期后还能用,排查时先打印 new Date(endAt).toString() 看是不是 Invalid Date,上线前要在目标机型实测(待确认)。

第三个问题:newUserOnly 如果被后端序列化成字符串 "false",在第一版里是真值,一张本来不限新客的券,老用户会看不到;反过来判断写反,新客券会对所有人展示。类型不对时,&& 只会按真假走,不会报错。

改法是在边界归一化,门槛用 ??,日期转成时间戳,优惠金额按订单金额截断:

function normalizeCoupon(raw) {
  const endAtMs = Date.parse(raw.endAt.replace(" ", "T"));
  return {
    id: String(raw.id),
    thresholdCents: Number(raw.threshold ?? 0),
    discountCents: Number(raw.discount),
    newUserOnly: raw.newUserOnly === true,
    endAtMs
  };
}

function pickBest(coupons, orderCents, isNewUser) {
  const best = coupons
    .filter(c => {
      if (orderCents < c.thresholdCents) return false;
      if (c.newUserOnly && !isNewUser) return false;
      if (!Number.isFinite(c.endAtMs) || Date.now() > c.endAtMs) return false;
      return true;
    })
    .reduce((pick, c) => {
      const cut = Math.min(c.discountCents, orderCents);
      return !pick || cut > pick.cut ? { coupon: c, cut } : pick;
    }, null);
  return best
    ? { coupon: best.coupon, payCents: orderCents - best.cut }
    : { coupon: null, payCents: orderCents };
}

88 元订单走一遍:第一张券门槛 0,通过;discountCents 1500 小于 8800,cut 是 1500;第二张门槛 9900 不通过;第三张 20000 不通过。结果是 payCents = 7300,展示 ¥73.00。券列表每次最多 12 张,结算页峰值约 400 QPS,前端过滤 12 条的开销可以忽略,不需要放进 Worker。

错误现象对照

结算、优惠这类页面出问题时,先对照现象,再决定往哪看:

现象真实原因第一步查什么
结算页白屏,报 Cannot read properties of undefined (reading 'discount')所有券被筛掉,pickBest 返回 undefined,页面直接取字段打印 filter 后的数组长度,确认是不是空
页面不崩,但无门槛券没出现,用户一分没减threshold || 9900 把合法的 0 换成了 9900打印原始 threshold 和 typeof
iOS 上券过期了还能用new Date("2026-11-11 23:59:59") 在 Safari 得到 Invalid Date打印 new Date(endAt).toString()
老用户看到「新客专享」券newUserOnly 是字符串 "false",在条件里算真值打印字段的 typeof,确认是 boolean 还是 string
应付金额算出负数优惠金额没按订单金额截断,减了比订单更多的钱看减法前有没有 Math.min
券后价显示 72.99999999999999金额用「元」浮点数计算看单位是元还是分,整数分不会出这个尾巴

边界与代价

?? 也不是所有默认值场景都该用。判断标准是「什么算没提供」:只有 null 和 undefined 算没提供,用 ??;如果业务上空字符串也算没填,就显式写 value === "" 再给默认值,别用一个 || 把 0、false、空串一起吞掉。团队里最常见的做法是默认值一律 ??,需要过滤假值时在代码里写明理由。

?. 的层数也有判断标准。两三层属性读取,用可选链很自然;写到 a?.b?.c?.d?.e 这种四五层,通常不是「数据可能缺」,而是前端拿到的数据结构太散,应该在接口层聚合,或者进前端时归一化一次。每层都加问号,等于把「字段缺失」这件事藏起来,页面空白但没人知道是接口少返回了东西。

== 的唯一例外是 value == null。团队里可以开 lint 的 eqeqeq,只允许和 null 比较;这样既保留了判空写法,又不会被别的隐式转换混进来。Object.is 适合判 NaN 和正负零,不要拿它替代所有 ===,两者在普通值上结果一样。

数据量和代价:12 张券、几千条订单记录,前端过滤排序都在毫秒级,没必要上 Worker;上万条候选券应该由后端筛完再下发,前端排序既慢又容易和服务端规则不一致。短路运算写副作用(flag && doRequest())在数据量小的时候看不出问题,出问题时最难查,因为读代码的人不知道那行到底执行了没有。

可选链和空值合并都是「防御性」工具,不是「正确性」工具。字段按约定必须存在时,让它报错比静默变成 undefined 更容易发现;真正需要防御的是接口明确可能不返回的字段。

小结

把这篇压成几条能直接用的判断:

场景推荐写法原因
判断有没有填内容value === "" / value.trim() === ""字符串真假和「有没有内容」不是一回事
判断数组有没有数据list.length > 0空数组是真值
判断空值value == null一次覆盖 null 和 undefined
其他比较===避免隐式转换带来的误判
默认值允许 0 / "" / false??|| 会把这些合法值吞掉
深层属性可能不存在?.省掉层层 &&,但别用来掩盖数据缺失

当天可以自己验证的几件事:

  1. 在控制台依次执行 0 || 99、0 ?? 99、"" ?? "匿名"、false ?? true,把四个结果写下来。
  2. 构造 const config = { threshold: 0 };,分别用 || 和 ?? 取默认值,确认只有后者保留 0。
  3. 执行 const a = { b: null }; a.b?.c、a.x?.y,再试 notDeclared?.name,观察哪一行报 ReferenceError。
  4. 用 Object.is(NaN, NaN)、Object.is(0, -0)、0 === -0 验证三个结果。
  5. 翻你项目里所有用 || 取默认值的地方,标出哪些字段的 0、空串、false 是合法值,逐个换成 ?? 或显式判空。

下一篇讲条件与循环。这一篇讲的是「一个值怎么判断」,下一篇讲「判断完怎么组织流程」:if 里哪些写法会越写越深、四种循环怎么选、forEach 为什么不理 await。先读它,是因为你写的每个默认值和每个短路,最后都会落进某个分支或循环里。