麻雀窝 Sparrow Zoo

0 == "" == true:JavaScript 宽松相等的类型强制陷阱

0 == "" == true 为什么等于 true?本文从宽松相等(==)与严格相等(===)的区别出发,拆解 JavaScript 隐式类型转换的完整规则,覆盖 falsy 值、字符串转数字、数组 ToPrimitive、null/undefined/NaN 特例与链式比较的左结合陷阱,附常见结果速查表与工程最佳实践。

前端 / 全栈开发者(了解基础 JS 语法)发布于 更新于
0 == "" == trueJavaScript 类型强制的经典陷阱true① 0 == "" → true · 空串转数字 0② true == true → true · 左结合连等== 宽松相等(隐式转换) ≠ === 严格相等
阅读目录

结论先行

一句话结论

0 == "" == true 的结果是 true,但这不是因为「0、空串、true 三者相等」,而是 JS 的 == 先做隐式类型转换、再按左结合依次比较:0 == "" 把空串转成 0 得 true,接着 true == true 仍为 true。

严谨的前提

这一结论只对宽松相等成立。改用严格相等 ===,0 === "" 直接就是 false,整条表达式也不再是 true。规范把 == 的行为定义在 ECMAScript 的 Abstract Equality Comparison(抽象相等比较)一节,上面所有「结果」都可由该算法严格推导。

问题背景

问题背景

JavaScript 是动态、弱类型语言:变量没有固定类型,== 在比较前会「体贴地」把两边转成同一类型再比。这对从 Java、Go 等强类型语言转过来的开发者,或习惯了 Python 链式比较的开发者,都容易造成误判。

一句 0 == "" == true 同时踩中了两个雷:隐式类型转换,以及链式 == 的左结合语义。理解它们,等于掌握了 JS 里最容易出 bug 的一小片地带。

先认识几个术语

宽松相等(==)
比较前先做隐式类型转换,再判断是否相等。
严格相等(===)
类型不同直接不相等,不做转换。
隐式类型转换(Coercion)
语言在背后自动把值从一种类型转成另一种类型,例如 Number("") 得到 0。
falsy / truthy
值在布尔上下文里被当成 false / true 的属性。

详细内容

结果先行:为什么是 true

先看结果——在浏览器控制台或 Node 里运行:

code
0 == "";          // true
0 == "" == true;  // true

第二行的 true 并不是「数学里的连等」推出来的。JS 的 == 是左结合的二元运算符,所以它实际被解析成:

(0 == "") == true;   // true == true → true

第一步 0 == "" 先把空字符串转成数字 0,于是 0 == 0 得 true;第二步 true == true 自然还是 true。所以整条表达式最终是 true。

关键

这个结果反直觉的地方在于:0 和 "" 明明类型不同,却「相等」了。根源是 == 的隐式类型转换,而不是数学上的数值相等。

宽松相等与严格相等:== 与 ===

JavaScript 提供两种相等判断:

  • 严格相等 ===:类型不同直接返回 false,不做任何转换。
  • 宽松相等 ==:类型不同时先做隐式转换,再比较。
code
0 === "";   // false —— 类型不同,直接不等
0 == "";    // true  —— 先把 "" 转成 0 再比较

"1" === 1;  // false
"1" == 1;   // true

绝大多数陷阱都出在 == 上。理解 == 的关键,是掌握它背后那条精确的规则——抽象相等比较算法。

抽象相等比较算法:几条核心规则

ECMAScript 规范把 x == y 的行为定义在「Abstract Equality Comparison」里。挑几条最常用的:

  1. 类型相同 → 退化为严格比较。
  2. null == undefined → 直接 true(这是特例)。
  3. 一方是数字、一方是字符串 → 把字符串转成数字再比。
  4. 一方是布尔 → 先把布尔转成数字(true→1、false→0)再比。
  5. 一方是对象、一方是原始值 → 先把对象用 ToPrimitive 转成原始值再比。

把这几条套到 0 == "":0 是数字、"" 是字符串,命中第 3 条,把 "" 转成 Number(""),结果是 0,于是 0 == 0 → true。

Falsy 值与 ==:两套容易混淆的规则

「falsy」是 Boolean() 语义:一个值转成布尔时是不是 false。全语言有 8 个 falsy 值:false、0、-0、0n、""、null、undefined、NaN。

而 == 是另一套规则,两者经常打架:

code
Boolean("");   // false —— "" 是 falsy
Boolean("0");  // true  —— "0" 非空,是 truthy
Boolean([]);   // true  —— 空数组也是 truthy

0 == "";       // true  —— 都转数字 0
"0" == 0;      // true  —— "0" 转数字 0

注意 []:它既是 truthy(Boolean([]) 为 true),又满足 [] == false(因为 [] 转字符串得 "",再转数字得 0)。falsy 与 == 相等不是一回事,别用前者去推后者。

字符串转数字:空串与空白的坑

比较中字符串转数字用的是 ToNumber,它把「空串」和「只含空白字符的串」都当成 0:

code
Number("");        // 0
Number(" ");       // 0   ← 只有空格也算空串
Number("\t\r\n");  // 0   ← 制表/换行也算
Number("0");       // 0
Number("abc");     // NaN

" " == 0;          // true

也就是说,0 == ""、0 == " "、甚至 0 == "\t" 都为 true。判断字符串是否为空时,务必先 trim() 或显式判断长度,别依赖这类隐式转换。

对象与数组:ToPrimitive 的坑

当 == 的一边是对象(数组也是对象),另一边是原始值时,会先用 ToPrimitive 把对象转成原始值。对数组来说,通常就是调用 toString():

code
[] == 0;          // true  —— [] 转成 "",再转成 0
[] == "";         // true
[0] == 0;         // true  —— "0" → 0
[1] == 1;         // true  —— "1" → 1
[1, 2] == "1,2";  // true  —— [1,2].toString() 是 "1,2"

对象转原始值的顺序(先 valueOf 再 toString)和 Symbol.toPrimitive 的优先级又是一层细节。日常开发里更稳妥的做法是:别让 == 去比较对象和原始值,直接显式转换后再比。

null、undefined、NaN 三个特殊值

这三个值是 == 规则里最需要单独记住的:

code
null == undefined;    // true   —— 规范特例
null === undefined;   // false  —— 严格相等类型不同

null == 0;            // false  —— null 只等于 null 或 undefined
undefined == 0;       // false

NaN == NaN;           // false  —— NaN 连自己都不等于

注意 null 是 falsy,但它 == 0 却是 false——这与 0 == "" 的「都转 0」完全不同,因为 null 走的是那条特例分支,不会被转成数字。判断 NaN 请用 Number.isNaN(),而不是 == 或 ===。

链式比较的左结合

在数学里,a == b == c 表示「a 等于 b 且 b 等于 c」。JS 不是这样:== 是普通的二元运算符,从左到右结合。

code
0 == "" == true;      // true

// 它其实是:
(0 == "") == true;    // (true) == true → true

Python 的链式比较会把它拆成 0 == "" and "" == True,结果反而是 False。同一行代码在不同语言里结果相反,正是这类「从别的语言带来的直觉」最危险的地方——跨语言时别把比较语义当成理所当然。

速查表与工程建议

常见结果速查:

宽松相等(==)常见结果
表达式结果原因
0 == ""true空串转数字 0
0 == "0"true"0" 转数字 0
0 == falsetruefalse 转数字 0
"" == falsetrue都转数字 0
" " == 0true空白串转数字 0
[] == 0true[] → "" → 0
[1] == 1true[1] → "1" → 1
null == undefinedtrue规范特例
null == 0falsenull 不走数字转换
NaN == NaNfalseNaN 不等于任何值
0 === ""false严格相等,类型不同

工程上的建议很简单:

code
// 默认用严格相等
if (value === 0) { /* ... */ }

// 唯一值得记的 == 惯用法:同时判断 null 与 undefined
if (value == null) { /* 等价于 value === null || value === undefined */ }

除「判空」这一个小例外,一律用 === 和 !==,把隐式转换这个不确定源挡在门外。

总结归纳

要点回顾

  • == 会隐式转换,=== 不会;陷阱几乎都来自 ==。
  • 0 == "" 为 true,因为空串、空白串转数字都是 0。
  • 数组比较先 toString,所以 [] == 0、[1] == 1 都为 true。
  • null 只与 null/undefined 宽松相等;NaN 连自己都不等。
  • 链式 == 是左结合,不是数学连等。

下一步

工程中默认写 ===/!==,只在需要同时判断 null 与 undefined 时使用 x == null 这个惯用法。想彻底吃透,可以顺着下文的官方链接,把抽象相等比较算法完整走一遍。

参考资料

  1. MDN — Equality comparisons and sameness

    宽松/严格相等与 SameValue 的官方文档,本文核心规则出处。

  2. ECMAScript 规范 — Abstract Equality Comparison

    == 的权威算法定义,逐条可核对。

  3. MDN — Falsy

    8 个 falsy 值的完整列表。

  4. MDN — Truthy

    truthy 的定义与示例。

  5. JavaScript Equality Table

    一张直观的 == 结果真值表,便于横向对照。