w wyl123ly 的博客
MD

JavaScript-01-基础语法与类型

44 KB 2026.10.11 原文件

JavaScript-01-基础语法与类型

本篇讲什么

这是 JavaScript 系列的第一篇,目标是让你不再靠猜写 JS。

内容包括:JS 的历史与定位、运行环境(浏览器引擎与 Node.js、解释与 JIT)、怎么跑代码、var/let/const 的完整对比、七种原始类型与对象类型、typeof 的历史怪癖、undefined 与 null 的区别、浮点数与 NaN 的陷阱、BigInt、字符串与模板字符串、类型转换规则表、== 与 ===、真假值、?? 与 ?.、流程控制与 for...of / for...in。

读完后你应该能解释"为什么 0.1 + 0.2 !== 0.3""为什么 typeof null === 'object'""为什么不建议用 ==",并能写出类型行为可预测的代码。


一、是什么:JavaScript 的历史与定位

JavaScript(常缩写为 JS)是一门动态类型、弱类型、单线程、基于原型的通用编程语言,也是 Web 浏览器唯一原生的脚本语言。

1.1 十天诞生,仓促导致的永久包袱

时间事件
1995 年 5 月Brendan Eich 在 Netscape 用 10 天写出了第一版 LiveScript
1995 年 12 月借 Java 的热度改名为 JavaScript,与 Java 毫无血缘关系,只是市场行为
1996 年微软做 JScript,浏览器出现互不兼容的两套实现
1997 年 6 月交给 ECMA 标准化,产出 ECMA-262 第 1 版,"JavaScript" 是商标,ECMAScript(ES) 才是规范名
2009 年ES5 发布,引入严格模式、JSON、Object.defineProperty
2015 年ES6 / ES2015 发布,一次补齐 let/const、箭头函数、类、Promise、模块
2016 年起改为每年一发:ES2016、ES2017……规范由 TC39 委员会维护

JavaScript 与 ECMAScript 的关系

ECMAScript 是规范文档(定义语法与语义),JavaScript 是规范的一个实现,再加上宿主环境提供的 API。

浏览器给 JS 加了 document、window、fetch;Node.js 给它加了 fs、process、http。

所以「JS 里有没有 fs 模块」这种问题的答案是:取决于宿主环境,不取决于语言。

因为设计时间只有十天,加上必须向后兼容(网页一旦上线就得永远能跑),早期决策留下的坑被永久保留:typeof null === 'object'、== 的隐式转换、0.1 + 0.2 !== 0.3。这些不是"设计得不好",而是一旦发布就无法修正的兼容性代价——理解这一点,你对 JS 的很多抱怨会变成"我知道它为什么这样"。

1.2 运行环境:从源码到机器码

JS 没有编译产物,但绝不是"逐行解释"那么慢。现代引擎采用 解释器 + JIT(Just-In-Time,即时编译) 的两级策略。

环境引擎说明
Chrome / Edge / Node.jsV8目前生态最主流的引擎,Node.js 直接嵌入它
FirefoxSpiderMonkey最早的 JS 引擎,Netscape 时代延续至今
SafariJavaScriptCore也叫 Nitro,苹果平台专用
Node.jsV8 + libuvV8 负责执行 JS,libuv 提供事件循环与异步 I/O

V8 的典型执行链路:

源码  ──解析──▶ AST ──Ignition 解释器──▶ 字节码 ──执行──▶ 结果
                                          │
                                    热点函数被标记
                                          ▼
                              TurboFan 优化编译器 ──▶ 机器码
                                          │
                              假设失效(类型变了)则去优化
                                          ▼
                                    退回字节码 + 重新学习

这个链路解释了两件工程事实

1. 不要过早优化:函数要被调用很多次才会进 JIT,跑一次的脚本优化开销纯属浪费。

2. 保持类型稳定:同一函数里 add(1, 2) 和 add("a", "b") 混着调用,会让 JIT 的优化假设失效并触发去优化(deoptimization),性能骤降。这是"为什么 TypeScript 能提升性能"的根本原因之一。

1.3 怎么运行代码

方式 A:浏览器控制台(打开 DevTools → Console,快捷键 F12 或 Ctrl+Shift+I)

// 控制台是"表达式求值"模式:输入表达式的值会被打印出来
1 + 1                 // 2
"a" + "b"             // 'ab'
// 浏览器控制台独有:可以用 $0 引用当前选中的 DOM 元素

方式 B:浏览器页面(保存为 index.html,双击用浏览器打开)

<!DOCTYPE html>
<html lang="zh-CN">
<body>
  <script>
    // 脚本放在 body 末尾:此时 DOM 已解析完,不用担心查不到元素
    console.log('在页面的 F12 控制台里查看这行输出');
  </script>
</body>
</html>

方式 C:Node.js(命令行,本篇所有示例都能在该环境运行)

node -v                      # 检查是否安装,推荐 18 LTS 及以上
node demo.js                 # 运行文件
node -e "console.log(1+1)"   # 直接执行一段代码
node                         # 进入 REPL 交互模式,输入 .exit 退出

本篇代码约定

所有代码示例都在 Node.js 18+ 下可直接运行(复制成 .js 文件后 node 文件名.js)。

用到 document、window、prompt 的地方会明确标注「浏览器」,它们在 Node 中不存在,直接跑会报 ReferenceError。

Node 里读取命令行参数用 process.argv,读取输入用 node:readline——这正是"语言 vs 宿主环境"的区别。


二、为什么这样设计:三个核心取舍

设计决策动机代价
弱类型 + 隐式转换网页脚本要处理来自 HTML 表单的字符串,宽松转换写起来短[] == false 为 true,行为反直觉,必须靠 === 兜底
单线程 + 事件循环浏览器 UI 不能被并发修改,多线程操作 DOM 需要锁,太复杂一个死循环就冻结整个页面;CPU 密集任务必须交给 Worker
基于原型而非类十天工期下,原型链比类系统实现成本低得多早期没有 class,继承写法冗长;ES6 的 class 只是语法糖,底层仍是原型
函数是一等公民回调式 API 与事件驱动模型需要把函数当数据传this 的绑定规则变得复杂,容易丢失(详见 [[JavaScript-02-函数与作用域]])
数值只有一种 number简化语言,避免整数溢出这类问题所有数字都是 IEEE 754 双精度浮点,整数超过 就不精确,且没有真正的整数除法

一句话总结

JS 的设计目标是"让网页能动起来",用宽容换上手速度。代价是"静默的错误行为"特别多——它很少抛异常,而是悄悄给你一个 NaN 或 undefined 继续往下跑。所以写 JS 的核心纪律是:类型要显式、比较要严格、边界要检查。


三、核心内容

3.1 三种变量声明:var / let / const

维度varletconst
引入版本ES1ES2015ES2015
作用域函数作用域(无视块)块级作用域 {}块级作用域 {}
提升(Hoisting)提升并初始化为 undefined提升但不初始化同 let
暂时性死区(TDZ)无有有
重复声明允许(静默覆盖)报 SyntaxError报 SyntaxError
挂到 window 上是(全局作用域下)否否
必须初始化否否是
能否重新赋值能能不能
现代用法避免使用需要重新赋值时默认选择
// ===== 作用域:var 是函数作用域,会"漏出"块 =====
function varLeak() {
  if (true) {
    var a = 1;   // 提升到整个函数顶部
    let b = 2;   // 只活在 if 块里
  }
  console.log(a); // 1:能访问,因为 var 无视块
  // console.log(b); // ReferenceError: b is not defined
}
varLeak();

// ===== 循环中的差异(闭包经典坑,详见第二篇)=====
for (var i = 0; i < 3; i++) { /* 循环结束后 i === 3 */ }
console.log(i); // 3:var 泄漏到外层

for (let j = 0; j < 3; j++) { /* 每次迭代都是一个新 j */ }
// console.log(j); // ReferenceError:let 被限制在块内
// ===== 暂时性死区(TDZ):从进入作用域到声明执行之间,访问会报错 =====
// console.log(x); // ReferenceError: Cannot access 'x' before initialization
let x = 1;

// 对比 var:不报错,但拿到的是 undefined —— 这种"静默错误"更危险
console.log(y); // undefined
var y = 2;

const 不等于"不可变"

const 锁住的是绑定(不能重新赋值),不是对象内容:

```js

const obj = { n: 1 };

obj.n = 99; // 合法:改的是对象内容

// obj = {}; // TypeError: Assignment to constant variable

```

想要真正的不可变,需要 Object.freeze()(浅冻结)或第三方库的深冻结,详见 JavaScript-03-对象与原型链。

// ===== 可运行示例:用 const 表达意图,只在必要时用 let =====
'use strict';

function countVowels(text) {
  const vowels = new Set(['a', 'e', 'i', 'o', 'u']); // 常量:值不会变,用 const
  let count = 0;                                     // 累加器:会被修改,用 let
  for (const ch of text.toLowerCase()) {
    // 只处理英文字母,避免把中文、空格、数字算进去
    if (vowels.has(ch)) count++;
  }
  return count;
}

console.log(countVowels('Hello JavaScript 世界')); // 5

// 用 Object.freeze 让"配置表"真正只读,防止后续代码误改
const CONFIG = Object.freeze({ retries: 3, timeoutMs: 1000 });
// CONFIG.retries = 5;   // 严格模式下抛 TypeError,非严格模式静默失败
console.log(CONFIG.retries); // 3

3.2 七种原始类型 + 一种对象类型

ECMAScript 规范把值分为原始值(primitive value)与对象(Object)两大类。原始类型共七种:

类型typeof 结果字面量示例说明
Undefined"undefined"undefined只有这一个值
Null"object" ⚠️null只有这一个值,typeof 是历史 bug
Boolean"boolean"true / false
Number"number"42、3.14、0xff、1e3IEEE 754 双精度,含 NaN、Infinity
String"string"'a'、"b"、` c `不可变,UTF-16 序列
Symbol"symbol"Symbol('id')ES2015,唯一且不可变,做属性键
BigInt"bigint"10nES2020,任意精度整数
Object"object" / "function"{}、[]、function(){}唯一不是原始值的类型
// ===== 原始值 vs 对象:最关键的区别是"值语义 vs 引用语义" =====
let s1 = 'hi';
let s2 = s1;      // 复制的是值本身
s2 = 'bye';
console.log(s1, s2); // hi bye —— 互不影响

const o1 = { n: 1 };
const o2 = o1;    // 复制的是"指向同一对象的引用"
o2.n = 99;
console.log(o1.n); // 99 —— 改一个等于改两个

String 是不可变的

字符串所有"修改"方法(toUpperCase、slice、replace)都返回新字符串,原字符串永不改变。

```js

const a = 'abc';

a.toUpperCase(); // 返回值是 'ABC',但 a 仍是 'abc'

console.log(a); // 'abc'

```

这个特性让字符串可以安全共享,也让"拼接循环"变成 的隐患——大字符串拼接请用数组 join('')。

复杂度上,str[i] 取单个 UTF-16 码元是 ,但 + 拼接最坏需要复制整个字符串,是 。

// ===== Symbol:解决"属性名撞车"的问题 =====
const user = {
  name: '张三',
  [Symbol('id')]: 1001, // 用 Symbol 做键:外部拿不到这个 Symbol 就访问不了
};

console.log(Object.keys(user));            // ['name'] —— Symbol 键不出现在这里
console.log(Object.getOwnPropertySymbols(user).length); // 1

// 用全局注册表跨模块共享同一个 Symbol(注意:不是私有,只是不会撞名)
const SHARED = Symbol.for('app.shared');
console.log(Symbol.for('app.shared') === SHARED); // true
console.log(Symbol('app.shared') === Symbol('app.shared')); // false —— 每次都是新的

3.3 typeof 的怪癖

console.log(typeof undefined);   // 'undefined'
console.log(typeof null);        // 'object'    ← 历史 bug,永远不会修
console.log(typeof true);        // 'boolean'
console.log(typeof 42);          // 'number'
console.log(typeof 'str');       // 'string'
console.log(typeof Symbol());    // 'symbol'
console.log(typeof 10n);         // 'bigint'
console.log(typeof {});          // 'object'
console.log(typeof []);          // 'object'    ← 数组也认不出来
console.log(typeof function(){}); // 'function' ← 函数是对象但单独返回
console.log(typeof class C {});  // 'function'  ← class 本质就是函数

为什么 typeof null === 'object'? 第一版 JS 用值的低位标记来区分类型:对象用 000,而 null 在当时的实现里被表示为空指针 0x00,于是它也命中了对象的判定分支。这个 bug 在 ES1 就被写进规范,1997 年之后任何修正都会让既有网页崩溃(很多代码用 typeof x === 'object' 来判对象),所以 TC39 只能保留它。ES6 曾提议 typeof null === 'null',因兼容性风险被否决。

三个必须记住的 typeof 缺口

1. null 判不出来 → 用 x === null。

2. 数组判不出来 → 用 Array.isArray(x)。

3. 未声明的变量用 typeof 不报错,返回 'undefined':

```js

// console.log(notDefined); // ReferenceError

console.log(typeof notDefined); // 'undefined' —— 只有 typeof 有这个豁免

```

第 3 点看起来方便,但它把"拼错变量名"变成了静默的 undefined,是常见 bug 来源。

// ===== 可运行示例:一个可靠的类型判定工具 =====
'use strict';

function typeOf(value) {
  if (value === null) return 'null';              // 先单独处理,绕开 typeof 的 bug
  if (Array.isArray(value)) return 'array';       // typeof 认不出数组
  const t = typeof value;
  if (t !== 'object') return t;                   // 原始类型和函数直接返回
  // 进一步区分普通对象、Date、Map 等:用 Object.prototype.toString
  return Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
}

console.log(typeOf(null));            // 'null'
console.log(typeOf([]));              // 'array'
console.log(typeOf(new Date()));      // 'date'
console.log(typeOf(new Map()));       // 'map'
console.log(typeOf({}));              // 'object'
console.log(typeOf(10n));             // 'bigint'
console.log(typeOf(() => {}));        // 'function'

3.4 undefined 与 null 的区别

维度undefinednull
含义系统给的"没有值":变量已声明未赋值、函数无返回值、缺失的属性/参数程序员主动写的"空值":明确表示"这里就是没有"
typeof'undefined''object'(bug)
转数字NaN0
转布尔falsefalse
转字符串'undefined''null'
JSON 序列化属性被丢弃输出 null
默认参数会触发默认值不会触发
Object.keys 中不出现(本身不是键)不出现
// ===== 什么时候会出现 undefined =====
let a;                       // ① 声明未赋值
function f() {}              // ② 函数没有 return
const o = {};                // ③ 访问不存在的属性
function g(p) { return p; }  // ④ 调用时少传实参

console.log(a, f(), o.missing, g()); // undefined undefined undefined undefined

// ===== 默认参数只对 undefined 生效,这是"故意设计" =====
function greet(name = '访客') { return `你好,${name}`; }
console.log(greet());         // '你好,访客' —— 没传 → undefined → 用默认值
console.log(greet(undefined));// '你好,访客' —— 显式传 undefined,同样用默认值
console.log(greet(null));     // '你好,null' —— null 是"我就是要空",不覆盖

工程约定:到底该用哪个

- 缺失的属性 / 未赋值:交给 undefined,让它自然出现,不要手动写 x = undefined。

- 主动表示"空":用 null,比如"查不到用户记录"、"这个字段后端返回空"。

- 判断为空用 x == null(会同时命中 null 和 undefined),这是 == 少数几个被推荐的用法。

```js

if (value == null) { / 同时覆盖 null 与 undefined,且不会误伤 0 和 '' / }

```

3.5 数值陷阱

JS 只有一个 number 类型,底层是 IEEE 754 双精度 64 位浮点:1 位符号 + 11 位指数 + 52 位尾数。

陷阱一:0.1 + 0.2 !== 0.3

和 在二进制下都是无限循环小数,只能被截断存储,相加后误差被放大:

这与语言无关——凡是使用 IEEE 754 双精度的语言(Python、C#、Java)都有同样行为。正确做法是比较差值而非相等。

陷阱二:NaN 不等于自己

NaN(Not a Number)是唯一一个 x !== x 为真的值。所以不能用 === NaN 检测,也不能用全局 isNaN(它会先做类型转换,isNaN('abc') 返回 true,误导性极强)。

方法NaN'abc'undefined说明
isNaN(x)(全局)truetruetrue先 Number(x) 再判断,不可靠
Number.isNaN(x)truefalsefalse只对真正的 NaN 返回 true,用这个

陷阱三:安全整数范围与 BigInt

能精确表示的最大整数是 ,即 Number.MAX_SAFE_INTEGER。

console.log(Number.MAX_SAFE_INTEGER);        // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 1);    // 9007199254740992 ✅
console.log(Number.MAX_SAFE_INTEGER + 2);    // 9007199254740992 ❌ 加 2 还是它
console.log(Number.MAX_SAFE_INTEGER + 3);    // 9007199254740994(跳过了 ...93)

BigInt(ES2020)用 n 后缀声明,任意精度,但要遵守三条限制:不能与 Number 混算、不能用 Math 方法、不能有小数。

// ===== 可运行示例:什么时候必须上 BigInt =====
'use strict';

// 场景:社交平台的文章 ID 用雪花算法生成,是 19 位整数
const idAsNumber = 1234567890123456789;
console.log(idAsNumber);                          // 1234567890123456800 —— 精度已丢
console.log(Number.isSafeInteger(idAsNumber));    // false —— 提前发现

const idAsBigInt = 1234567890123456789n;          // 加 n 就是 BigInt,精确
console.log(idAsBigInt.toString());               // '1234567890123456789'

// 阶乘很快超出安全整数范围,用 BigInt 才正确
function factorial(n) {
  let result = 1n;                                // 注意初始值是 1n 而不是 1
  for (let i = 2n; i <= BigInt(n); i++) {
    result *= i;                                  // BigInt 之间运算必须都是 BigInt
  }
  return result;
}
console.log(factorial(25).toString()); // 15511210043330985984000000 —— 精确值

// 与 Number 混算会直接抛错,这是"故意"的:避免静默丢精度
try {
  console.log(1n + 1);
} catch (e) {
  console.log(e.constructor.name, '-', e.message); // TypeError - Cannot mix BigInt and other types
}

陷阱四:浮点数比较与货币计算

// ===== 可运行示例:正确的浮点比较 =====
'use strict';

// 方案一:误差容限比较,适合"近似相等"的物理/图形计算
function approxEqual(a, b, epsilon = Number.EPSILON) {
  // Number.EPSILON ≈ 2.220446049250313e-16,是 1 与"下一个可表示数"的间距
  // 乘上 max(1, |a|, |b|) 是为了在数值较大时按比例放宽误差
  return Math.abs(a - b) < epsilon * Math.max(1, Math.abs(a), Math.abs(b));
}
console.log(0.1 + 0.2 === 0.3);          // false
console.log(approxEqual(0.1 + 0.2, 0.3)); // true

// 方案二:金额一律用"最小货币单位"的整数运算,这是生产环境的通行做法
function addMoney(yuanA, yuanB) {
  const toFen = (y) => Math.round(y * 100); // 元 → 分,四舍五入消除表示误差
  const totalFen = toFen(yuanA) + toFen(yuanB);
  return totalFen / 100;
}
console.log(0.1 + 0.2);                  // 0.30000000000000004
console.log(addMoney(0.1, 0.2));         // 0.3 ✅

// 附:Object.is 与 === 的差别,只在这两个值上不同
console.log(NaN === NaN, Object.is(NaN, NaN));   // false true
console.log(0 === -0, Object.is(0, -0));         // true false

数值相关的四个死坑

1. 别用 === 比较浮点结果,用误差容限或整数化。

2. NaN 传染:任何含 NaN 的算术结果都是 NaN,且用 === 查不出来 → 一律用 Number.isNaN()。

3. Infinity 会静默扩散:1 / 0 === Infinity、Infinity - Infinity === NaN,而且 Infinity 参与 JSON 序列化会变成 null。

4. 位数超过 15~16 位的整数就别用 number:数据库 BIGINT 主键、分布式 ID 一旦被解析成 JS 数字就会悄悄丢精度(如 19 位雪花 ID 末尾几位变 0),后端必须把它序列化成字符串再返回 —— 这是前后端联调最常见的翻车点。

3.6 字符串与模板字符串

写法语法换行插值适用场景
单引号'abc'不支持不支持普通字符串(团队偏好)
双引号"abc"不支持不支持含单引号时少转义,如 "it's"
模板字符串` abc `支持${expr}拼接变量、多行文本、HTML 片段
标签模板` tagabc `支持支持styled-components、sql 防注入
// ===== 可运行示例:模板字符串改变的不只是写法 =====
'use strict';

const user = { name: '李四', vip: true, orders: 3 };

// ① 插值可以是任意表达式,不必先声明变量
const line = `${user.name} ${user.vip ? '(VIP)' : ''} 有 ${user.orders * 2} 张券`;
console.log(line); // '李四 (VIP) 有 6 张券'

// ② 天然支持多行,避免一堆 \n 和 + 号
const report = `用户:${user.name}
订单:${user.orders}
状态:${user.vip ? 'VIP' : '普通'}`;
console.log(report);

// ③ 标签模板:让函数接管字符串的拼接过程,可以做转义、翻译、防注入
function safeHtml(strings, ...values) {
  const escape = (v) => String(v).replace(/[&<>"']/g, (c) => ({
    '&': '&', '<': '<', '>': '>', '"': '"', "'": ''',
  }[c]));
  // strings 是模板里的静态文本片段,values 是插值表达式的结果
  return strings.reduce((acc, s, i) => acc + s + (i < values.length ? escape(values[i]) : ''), '');
}
const evil = '<img src=x onerror=alert(1)>';
console.log(safeHtml`<p>${evil}</p>`); // 尖括号全部被转义,注入失效

// ④ 常用字符串 API:都是返回新字符串,原串不变
console.log('a-b-c'.split('-'));         // ['a', 'b', 'c']
console.log('  pad  '.trim());           // 'pad'
console.log('abc'.includes('b'));        // true
console.log('abc'.padStart(5, '0'));     // '00abc'
console.log('a,b,,c'.split(',').filter(Boolean)); // ['a','b','c'],过滤空串

3.7 类型转换

显式转换(推荐)

目标写法结果要点
数字Number(x)Number('') === 0、Number('12px') === NaN;parseInt('12px') === 12 会截断
整数parseInt(x, 10)必须写第二个参数,否则 parseInt('08') 在旧引擎里按八进制解析
浮点parseFloat(x)遇到非法字符就停止,不报错
字符串String(x)null/undefined 都能安全转;x.toString() 遇到 null 会抛错
布尔Boolean(x)见下文 falsy 列表;简写 !!x

隐式转换(+ 号的两副面孔)

+ 是唯一一个"既能算术又能拼接"的运算符,规则是:只要有一边是字符串(或能转成字符串的对象),就走拼接。

表达式结果原因
1 + 23都是数字 → 加法
'1' + 2'12'有字符串 → 拼接
1 + '2''12'同上,顺序不影响
1 + 2 + '3''33'从左到右:1+2=3,再 3+'3'='33'
'1' + 2 + 3'123''1'+2='12',再 '12'+3='123'
1 - '2'-1- 只有算术含义 → 字符串被转成数字
'6' / '2'3同上
[] + {}'[object Object]'两边都转字符串再拼接
1 + null1Number(null) === 0
1 + undefinedNaNNumber(undefined) === NaN
true + 12Number(true) === 1
// ===== 可运行示例:表单输入全是字符串,转换必须显式 =====
'use strict';

// Node 里模拟"从表单拿到两个字符串",注意 process.argv 里的值也是字符串
function parseQuantity(input) {
  const n = Number(input);          // 统一入口,比 +input 语义清楚
  if (!Number.isFinite(n)) {        // isFinite 同时排除 NaN 和 ±Infinity
    throw new TypeError(`数量必须是有限数字,收到:${JSON.stringify(input)}`);
  }
  return Math.trunc(n);             // 数量取整,避免 1.9 件商品
}

console.log(parseQuantity('42'));   // 42
console.log(parseQuantity('42.9')); // 42
try {
  parseQuantity('42px');
} catch (e) {
  console.log(e.message);           // 数量必须是有限数字,收到:"42px"
}

// 陷阱复现:直接用 + 拼接会得到意料之外的字符串
const a = '5', b = 3;
console.log(a + b);      // '53'  ← 典型 bug
console.log(+a + b);     // 8     ← 一元 + 是"转数字",不是拼接
console.log(Number(a) + b); // 8   ← 更推荐,意图明确

== 与 === 的转换表

===(严格相等)要求类型和值都相同,不做任何转换;==(宽松相等)会按规范做转换。核心规则:只要两边类型不同,就尝试转成数字比较(null/undefined 互等是唯一特例)。

xyx == yx === y说明
1'1'truefalse字符串转数字
0falsetruefalse都转成 0
''falsetruefalse⚠️ 最容易出事的一行
' \t'0truefalse空白串转 0
nullundefinedtruefalse唯一特例:规范明确规定
null0falsefalsenull 只和 undefined 宽松相等
NaNNaNfalsefalseNaN 不等于任何值
[]falsetruefalse[] 先转 '' 再转 0
[]''truefalse[] 转 ''
[1]1truefalse[1] 转 '1' 再转 1
[1,2]'1,2'truefalse数组转字符串用 join(',')
{}'[object Object]'truefalse对象转字符串
new Number(1)1truefalse包装对象 → === 会区分类型
0-0truetrue=== 不区分正负零

结论:永远用 ===

== 的规则是 3 条以上转换链的组合,人脑记不住,代码审查也看不出来。唯一例外是 x == null——它精确表达"是 null 或 undefined",比 x === null || x === undefined 更简洁。

想彻底禁止 ==,在项目里开启 ESLint 的 eqeqeq 规则;想检查 NaN 用 Number.isNaN(),想检查 -0 用 Object.is()。

3.8 真假值(falsy)

falsy 值只有 8 个(ES2020 前是 7 个),其余一切值——包括空数组 []、空对象 {}、'0'、'false'——都是 truthy。

// ===== 完整的 falsy 列表,建议背下来 =====
const falsy = [false, 0, -0, 0n, '', null, undefined, NaN];
console.log(falsy.every((v) => !v));            // true:全部为假
console.log(falsy.map((v) => typeof v));        // ['boolean','number','number','bigint','string','object','undefined','number']

// ===== 最容易踩的两个"看着像假,其实是真" =====
console.log(Boolean([]));      // true  ← 空数组是真值!
console.log(Boolean({}));      // true  ← 空对象是真值!
console.log(Boolean('0'));     // true  ← 非空字符串就是真
console.log(Boolean('false')); // true
console.log(Boolean(new Boolean(false))); // true ← 包装对象也是真值
// ===== 可运行示例:判空要写清楚,别依赖 truthy/falsy =====
'use strict';

// 反例:score 为 0 分时会被误判成"未评分"
function badGrade(score) {
  return score ? `得分 ${score}` : '未评分';
}
console.log(badGrade(0));    // '未评分' ← bug

// 正例:把"有没有值"和"值是多少"分开判断
function goodGrade(score) {
  if (score === null || score === undefined) return '未评分';
  if (!Number.isFinite(score) || score < 0 || score > 100) return '分数非法';
  return `得分 ${score}`;
}
console.log(goodGrade(0));      // '得分 0' ✅
console.log(goodGrade(null));   // '未评分'
console.log(goodGrade(120));    // '分数非法'

// 正例:判断数组/字符串是否为空,用 length 而不是真假值
function isEmptyText(s) { return s.trim().length === 0; }
console.log(isEmptyText('   ')); // true —— 用 Boolean('   ') 会得到 false,误判为非空

3.9 运算符:??、?.、逻辑运算符的返回值

逻辑运算符返回的是原值,不是布尔值:a || b 命中假值时返回 b 本身,a && b 命中真值时返回 b 本身。

运算符名称何时返回右操作数典型用途
`a \\b`逻辑或a 是 falsy 时兜底默认值(⚠️ 会把 0、'' 也替换掉)
a && b逻辑与a 是 truthy 时守卫式调用、条件执行
a ?? b空值合并(ES2020)a 是 null 或 undefined 时只兜底"缺失",保留 0 和 ''
a?.b可选链(ES2020)a 为 null/undefined 时整体返回 undefined安全访问深层属性
// ===== 可运行示例:?? 与 || 的关键差异 =====
'use strict';

const settings = { volume: 0, title: '', theme: null };

// 反例:|| 会把合法的 0 和 '' 当成"没设置"
console.log(settings.volume || 50);  // 50 ← 用户明明静音了,却被改成 50
console.log(settings.title || '未命名'); // '未命名' ← 用户清空标题的意图被覆盖

// 正例:?? 只在真正缺失时兜底
console.log(settings.volume ?? 50);  // 0   ✅
console.log(settings.title ?? '未命名'); // '' ✅
console.log(settings.theme ?? 'dark'); // 'dark' ✅

// 可选链:安全访问可能不存在的深层属性
const apiResponse = { data: { user: { profile: { nickname: '王五' } } } };
console.log(apiResponse.data?.user?.profile?.nickname);      // '王五'
console.log(apiResponse.data?.user?.avatar?.url);            // undefined,不抛错
// console.log(apiResponse.data.user.avatar.url);            // TypeError: Cannot read properties of undefined

// 可选链 + 空值合并是处理"可选配置"的黄金组合
const pageSize = apiResponse.meta?.pageSize ?? 20;  // 缺失时用默认值
console.log(pageSize); // 20

// 逻辑运算符的"短路"还能当条件执行用,但可读性不如 if
const cache = new Map();
const value = cache.get('k') ?? (() => {
  const computed = 'expensive';       // 模拟昂贵计算
  cache.set('k', computed);
  return computed;
})();
console.log(value); // 'expensive'

// ⚠️ 语法限制:?? 不能与 || / && 直接混用,必须加括号
// const bad = a ?? b || c;   // SyntaxError
const ok = (undefined ?? 1) || 2;
console.log(ok); // 1

3.10 流程控制

if / switch / while / do...while 与其他语言基本一致,重点讲两个 JS 特有的循环和几个易错点。

循环遍历目标拿到的值能否 break是否遍历原型链
for (const x of arr)可迭代对象(数组、字符串、Map、Set)值能否
for (const k in obj)可枚举属性名键(字符串)能会
arr.forEach()数组值不能否
arr.map/filter/reduce数组返回值组成新数组不能否

for...in 用错是高频事故

它遍历的是属性名且包含继承来的可枚举属性,对数组使用还会得到字符串下标的顺序不确定性。结论:

- 遍历数组/任何可迭代对象 → 一律用 for...of。

- 遍历普通对象的键 → 用 Object.keys(obj) / Object.entries(obj),不要用 for...in。

- 必须用 for...in 时,加 if (!Object.hasOwn(obj, k)) continue; 过滤继承属性。

// ===== 可运行示例:三种遍历的差别(Node.js 可直接运行)=====
'use strict';

const arr = ['a', 'b', 'c'];

// ① for...of:拿到值,能用 break / continue,推荐
for (const ch of arr) {
  if (ch === 'b') continue;   // 跳过 b
  process.stdout.write(ch);   // 输出 ac
}
console.log();

// ② entries() 同时拿到下标和值——比 for(let i...) 更少出错
for (const [index, ch] of arr.entries()) {
  console.log(index, ch);
}

// ③ for...in 遍历数组:拿到的是字符串下标,且顺序不保证
for (const key in arr) {
  console.log(typeof key, key); // string '0' / '1' / '2'
}

// ④ 对象遍历:用 Object.entries,避免 for...in 带出原型属性
const scores = { 语文: 90, 数学: 85 };
Object.defineProperty(scores, 'inherited', { value: 1, enumerable: true }); // 模拟原型污染
for (const k in scores) console.log('in:', k);            // 会多出 inherited
for (const [k, v] of Object.entries(scores)) console.log('entries:', k, v); // 只有自己的

// ⑤ switch 用 === 比较,必须记得 break;用对象映射表可以避免穿透 bug
function priceOf(level) {
  const table = { basic: 10, pro: 30, team: 100 };  // 映射表:无穿透风险
  return table[level] ?? 0;                          // 未知等级返回 0
}
console.log(priceOf('pro'), priceOf('unknown')); // 30 0
// ===== 可运行示例:把前几节知识合成一个小工具 =====
'use strict';

/**
 * 计算购物车总价。
 * 金额一律用「分」做整数运算,避免浮点误差(见 3.5 节)。
 */
function totalPrice(items, { memberLevel = 'basic', useCoupon = null } = {}) {
  if (!Array.isArray(items)) throw new TypeError('items 必须是数组');

  let totalFen = 0;
  for (const item of items) {
    const { price, qty = 1 } = item;                 // 解构 + 默认值,缺 qty 时按 1 件
    if (!Number.isFinite(price) || price < 0) continue; // 跳过脏数据而不是崩溃
    totalFen += Math.round(price * 100) * qty;
  }

  const discountTable = { basic: 1, pro: 0.95, team: 0.9 };
  const rate = discountTable[memberLevel] ?? 1;       // ?? 保证未知等级不打折
  totalFen = Math.round(totalFen * rate);
  if (useCoupon != null && useCoupon > 0) {           // == null 同时挡住 null/undefined
    totalFen = Math.max(0, totalFen - Math.round(useCoupon * 100));
  }
  return totalFen / 100;                              // 分 → 元,只在最后转一次
}

const cart = [
  { price: 19.9, qty: 2 },
  { price: 0.1 },                    // 没写 qty,按 1 件
  { price: 'abc' },                  // 脏数据,会被跳过
];
console.log(totalPrice(cart));                                  // 39.9
console.log(totalPrice(cart, { memberLevel: 'pro' }));           // 37.91(约 39.9*0.95)
console.log(totalPrice(cart, { memberLevel: 'pro', useCoupon: 5 })); // 32.91

四、注意事项与常见坑

十个最常见的基础语法陷阱

1. typeof null === 'object' → 判 null 用 ===,判数组用 Array.isArray()。

2. == 隐式转换 → 一律 ===,只把 x == null 当特例使用。

3. 0.1 + 0.2 !== 0.3 → 浮点比较用误差容限;金额用整数分。

4. NaN !== NaN → 用 Number.isNaN(),不要用全局 isNaN()。

5. || 把 0 / '' 当假值 → 需要保留它们时用 ??。

6. for...in 遍历数组 → 改用 for...of 或 entries(),且它会带出原型属性。

7. const 对象仍可改 → 想真不可变用 Object.freeze()(只是浅冻结)。

8. 超长整数丢精度 → 19 位 ID 用 BigInt 或字符串,别用 number 接收。

9. let/const 的 TDZ → 声明前访问会抛错,养成"声明放使用前"的习惯。

10. + 的拼接陷阱 → 表单值全是字符串,先 Number() 再算。

三个会静默出错、不报异常的场景

- Number('') 是 0,不是 NaN。空输入框会让总价莫名变成 0。

- JSON.parse 收到 undefined 会抛错,但 JSON.stringify(undefined) 返回 undefined 而不是字符串。

- Array(3) 造出的是 3 个空洞而不是 [3];[1,2,3].length = 1 会直接截断数组。


五、练习题

练习 1(类型判定)

写一个 isEmpty(value),对 null、undefined、''、' '、[]、{}、空 Map、0、false 分别返回"空"或"非空",并说明你对 0 和 false 的选择理由。

练习 2(浮点与金额)

用 number 计算 0.1 + 0.2 - 0.3,打印结果并解释为什么不是 0。然后改写为"以分为单位"的版本,使结果为 0。

练习 3(相等性)

不运行代码,先写出下列表达式的值,再用 Node 验证并解释每一行:

'1' == 1、'1' === 1、null == 0、null == undefined、[] == false、[1,2] == '1,2'、NaN == NaN、0 == -0。

练习 4(可选链与空值合并)

给定 const cfg = { retry: 0, name: '', nested: null },分别用 || 和 ?? 取出这三个字段并提供默认值,列出两次结果的差异并解释。

练习 5(遍历)

有一个对象 { a: 1, b: 2 } 且其原型上有可枚举属性 c。分别用 for...in、Object.keys、Object.entries 遍历,打印结果并说明为什么三者输出不同。


六、常见问题 FAQ

let 和 var 我该用哪个?

默认 const,需要重新赋值时用 let,基本不用 var。var 只有两个真实用途:需要函数级提升的遗留代码、以及维护老项目。新代码里 var 带来的作用域泄漏与重复声明静默覆盖,几乎只会制造 bug。

既然 0.1 + 0.2 !== 0.3,JS 的数字是不是不能用?

能用,但要知道边界。它精确表示整数的范围是 ,做普通业务计算完全够;问题只出现在三类场景:金额(用整数分或 decimal 库)、超大整数 ID(用 BigInt 或字符串)、需要精确相等的比较(用误差容限)。本质上这是 IEEE 754 的性质,Python 的 float、C# 的 double 完全一样。

null 和 undefined 我该往数据库/接口里存哪个?

约定比选择更重要。常见做法:"字段不存在/未提供"用 undefined(JSON 序列化时整个键消失),"字段存在但值为空"用 null(JSON 里保留 null)。这样前端能区分"后端没返回这个字段"和"后端明确告诉你它是空的"。

为什么 typeof [] 是 'object',typeof function(){} 却是 'function'?

因为数组和函数都是对象,规范里唯一为"可调用对象"开的特例就是 'function'。想要精确判定请用:Array.isArray() 判数组、typeof x === 'function' 判可调用、x instanceof Date 判具体类,或者 Object.prototype.toString.call(x) 这个万能写法(见 3.3 节示例)。


相关笔记

  • JavaScript-02-函数与作用域 —— 函数、this、闭包、作用域链,本篇提到的 TDZ 与提升在那里有完整机制讲解
  • JavaScript-03-对象与原型链 —— 对象、属性描述符、原型链、class 与继承
  • JavaScript-04-异步编程 —— 事件循环、Promise、async/await
  • JavaScript-07-ES6新特性 —— 解构、展开、Symbol、Proxy 的系统梳理
  • 编程语言对比 —— 与 Python / C# 的类型系统对照
  • 算法-复杂度分析 —— 本篇 、 记号的定义与推导
  • 常见问题FAQ —— 跨方向的通用问题

参考来源