---
title: JavaScript-01-基础语法与类型
aliases:
  - JavaScript 基础语法
  - JS 类型系统
  - JavaScript Basics
tags:
  - 编程语言/JavaScript
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 入门
prerequisites:
  - "[[00-索引]]"
  - "[[计算机组成原理]]"
sources:
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Data_structures
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/typeof
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Equality
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Strict_equality
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/BigInt
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Optional_chaining
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for...of
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for...in
  - https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy
  - https://tc39.es/ecma262/
  - https://zh.javascript.info/types
  - https://zh.javascript.info/type-conversions
  - https://zh.javascript.info/comparison
  - https://nodejs.org/en/learn/getting-started/introduction-to-nodejs
  - https://v8.dev/blog
---

# JavaScript-01-基础语法与类型

> [!abstract] 本篇讲什么
> 这是 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 委员会维护 |

> [!note] 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.js | V8 | 目前生态最主流的引擎，Node.js 直接嵌入它 |
| Firefox | SpiderMonkey | 最早的 JS 引擎，Netscape 时代延续至今 |
| Safari | JavaScriptCore | 也叫 Nitro，苹果平台专用 |
| Node.js | V8 + libuv | V8 负责执行 JS，libuv 提供事件循环与异步 I/O |

V8 的典型执行链路：

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

> [!important] 这个链路解释了两件工程事实
> 1. **不要过早优化**：函数要被调用很多次才会进 JIT，跑一次的脚本优化开销纯属浪费。
> 2. **保持类型稳定**：同一函数里 `add(1, 2)` 和 `add("a", "b")` 混着调用，会让 JIT 的优化假设失效并触发**去优化（deoptimization）**，性能骤降。这是"为什么 TypeScript 能提升性能"的根本原因之一。

### 1.3 怎么运行代码

**方式 A：浏览器控制台**（打开 DevTools → Console，快捷键 `F12` 或 `Ctrl+Shift+I`）

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

**方式 B：浏览器页面**（保存为 `index.html`，双击用浏览器打开）

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

**方式 C：Node.js**（命令行，本篇所有示例都能在该环境运行）

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

> [!tip] 本篇代码约定
> 所有代码示例都在 **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 双精度浮点，整数超过 $2^{53}-1$ 就不精确，且没有真正的整数除法 |

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

---

## 三、核心内容

### 3.1 三种变量声明：`var` / `let` / `const`

| 维度 | `var` | `let` | `const` |
|---|---|---|---|
| 引入版本 | ES1 | ES2015 | ES2015 |
| 作用域 | **函数作用域**（无视块） | **块级作用域** `{}` | 块级作用域 `{}` |
| 提升（Hoisting） | 提升并初始化为 `undefined` | 提升但**不初始化** | 同 `let` |
| 暂时性死区（TDZ） | 无 | 有 | 有 |
| 重复声明 | 允许（静默覆盖） | 报 `SyntaxError` | 报 `SyntaxError` |
| 挂到 `window` 上 | 是（全局作用域下） | 否 | 否 |
| 必须初始化 | 否 | 否 | **是** |
| 能否重新赋值 | 能 | 能 | **不能** |
| 现代用法 | 避免使用 | 需要重新赋值时 | **默认选择** |

```js
// ===== 作用域：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 被限制在块内
```

```js
// ===== 暂时性死区（TDZ）：从进入作用域到声明执行之间，访问会报错 =====
// console.log(x); // ReferenceError: Cannot access 'x' before initialization
let x = 1;

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

> [!warning] `const` 不等于"不可变"
> `const` 锁住的是**绑定**（不能重新赋值），不是**对象内容**：
> ```js
> const obj = { n: 1 };
> obj.n = 99;        // 合法：改的是对象内容
> // obj = {};       // TypeError: Assignment to constant variable
> ```
> 想要真正的不可变，需要 `Object.freeze()`（浅冻结）或第三方库的深冻结，详见 [[JavaScript-03-对象与原型链]]。

```js
// ===== 可运行示例：用 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`、`1e3` | IEEE 754 双精度，含 `NaN`、`Infinity` |
| String | `"string"` | `'a'`、`"b"`、`` `c` `` | **不可变**，UTF-16 序列 |
| Symbol | `"symbol"` | `Symbol('id')` | ES2015，唯一且不可变，做属性键 |
| BigInt | `"bigint"` | `10n` | ES2020，任意精度整数 |
| **Object** | `"object"` / `"function"` | `{}`、`[]`、`function(){}` | 唯一不是原始值的类型 |

```js
// ===== 原始值 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 —— 改一个等于改两个
```

> [!important] String 是不可变的
> 字符串所有"修改"方法（`toUpperCase`、`slice`、`replace`）都**返回新字符串**，原字符串永不改变。
> ```js
> const a = 'abc';
> a.toUpperCase();      // 返回值是 'ABC'，但 a 仍是 'abc'
> console.log(a);       // 'abc'
> ```
> 这个特性让字符串可以安全共享，也让"拼接循环"变成 $O(n^2)$ 的隐患——大字符串拼接请用数组 `join('')`。
> 复杂度上，`str[i]` 取单个 UTF-16 码元是 $O(1)$，但 `+` 拼接最坏需要复制整个字符串，是 $O(n)$。

```js
// ===== 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` 的怪癖

```js
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'`，因兼容性风险被否决。

> [!warning] 三个必须记住的 `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 来源。

```js
// ===== 可运行示例：一个可靠的类型判定工具 =====
'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` 的区别

| 维度 | `undefined` | `null` |
|---|---|---|
| 含义 | **系统**给的"没有值"：变量已声明未赋值、函数无返回值、缺失的属性/参数 | **程序员**主动写的"空值"：明确表示"这里就是没有" |
| `typeof` | `'undefined'` | `'object'`（bug） |
| 转数字 | `NaN` | `0` |
| 转布尔 | `false` | `false` |
| 转字符串 | `'undefined'` | `'null'` |
| JSON 序列化 | 属性**被丢弃** | 输出 `null` |
| 默认参数 | **会**触发默认值 | **不会**触发 |
| `Object.keys` 中 | 不出现（本身不是键） | 不出现 |

```js
// ===== 什么时候会出现 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 是"我就是要空"，不覆盖
```

> [!tip] 工程约定：到底该用哪个
> - **缺失的属性 / 未赋值**：交给 `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`**

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

$$0.1_{10} + 0.2_{10} = 0.30000000000000004_{10} \neq 0.3_{10}$$

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

**陷阱二：`NaN` 不等于自己**

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

| 方法 | `NaN` | `'abc'` | `undefined` | 说明 |
|---|---|---|---|---|
| `isNaN(x)`（全局） | `true` | `true` | `true` | 先 `Number(x)` 再判断，**不可靠** |
| `Number.isNaN(x)` | `true` | `false` | `false` | **只对真正的 `NaN` 返回 true，用这个** |

**陷阱三：安全整数范围与 `BigInt`**

能精确表示的最大整数是 $2^{53} - 1 = 9007199254740991$，即 `Number.MAX_SAFE_INTEGER`。

```js
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` 方法**、**不能有小数**。

```js
// ===== 可运行示例：什么时候必须上 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
}
```

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

```js
// ===== 可运行示例：正确的浮点比较 =====
'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
```

> [!warning] 数值相关的四个死坑
> 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 片段 |
| 标签模板 | `` tag`abc` `` | 支持 | 支持 | `styled-components`、`sql` 防注入 |

```js
// ===== 可运行示例：模板字符串改变的不只是写法 =====
'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) => ({
    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
  }[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 + 2` | `3` | 都是数字 → 加法 |
| `'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 + null` | `1` | `Number(null) === 0` |
| `1 + undefined` | `NaN` | `Number(undefined) === NaN` |
| `true + 1` | `2` | `Number(true) === 1` |

```js
// ===== 可运行示例：表单输入全是字符串，转换必须显式 =====
'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` 互等是唯一特例）。

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

> [!important] 结论：永远用 `===`
> `==` 的规则是 3 条以上转换链的组合，人脑记不住，代码审查也看不出来。**唯一例外**是 `x == null`——它精确表达"是 `null` 或 `undefined`"，比 `x === null || x === undefined` 更简洁。
> 想彻底禁止 `==`，在项目里开启 ESLint 的 [`eqeqeq`](https://eslint.org/docs/latest/rules/eqeqeq) 规则；想检查 `NaN` 用 `Number.isNaN()`，想检查 `-0` 用 `Object.is()`。

### 3.8 真假值（falsy）

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

```js
// ===== 完整的 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 ← 包装对象也是真值
```

```js
// ===== 可运行示例：判空要写清楚，别依赖 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` | 安全访问深层属性 |

```js
// ===== 可运行示例：?? 与 || 的关键差异 =====
'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` | 数组 | 返回值组成新数组 | 不能 | 否 |

> [!warning] `for...in` 用错是高频事故
> 它遍历的是**属性名**且**包含继承来的可枚举属性**，对数组使用还会得到字符串下标的顺序不确定性。结论：
> - 遍历**数组/任何可迭代对象** → 一律用 `for...of`。
> - 遍历**普通对象的键** → 用 `Object.keys(obj)` / `Object.entries(obj)`，不要用 `for...in`。
> - 必须用 `for...in` 时，加 `if (!Object.hasOwn(obj, k)) continue;` 过滤继承属性。

```js
// ===== 可运行示例：三种遍历的差别（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
```

```js
// ===== 可运行示例：把前几节知识合成一个小工具 =====
'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
```

---

## 四、注意事项与常见坑

> [!warning] 十个最常见的基础语法陷阱
> 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()` 再算。

> [!danger] 三个会静默出错、不报异常的场景
> - **`Number('')` 是 `0`**，不是 `NaN`。空输入框会让总价莫名变成 0。
> - **`JSON.parse` 收到 `undefined` 会抛错**，但 `JSON.stringify(undefined)` 返回 `undefined` 而不是字符串。
> - **`Array(3)` 造出的是 3 个空洞**而不是 `[3]`；`[1,2,3].length = 1` 会直接截断数组。

---

## 五、练习题

> [!question] 练习 1（类型判定）
> 写一个 `isEmpty(value)`，对 `null`、`undefined`、`''`、`'   '`、`[]`、`{}`、空 `Map`、`0`、`false` 分别返回"空"或"非空"，并说明你对 `0` 和 `false` 的选择理由。

> [!question] 练习 2（浮点与金额）
> 用 `number` 计算 `0.1 + 0.2 - 0.3`，打印结果并解释为什么不是 `0`。然后改写为"以分为单位"的版本，使结果为 `0`。

> [!question] 练习 3（相等性）
> 不运行代码，先写出下列表达式的值，再用 Node 验证并解释每一行：
> `'1' == 1`、`'1' === 1`、`null == 0`、`null == undefined`、`[] == false`、`[1,2] == '1,2'`、`NaN == NaN`、`0 == -0`。

> [!question] 练习 4（可选链与空值合并）
> 给定 `const cfg = { retry: 0, name: '', nested: null }`，分别用 `||` 和 `??` 取出这三个字段并提供默认值，列出两次结果的差异并解释。

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

---

## 六、常见问题 FAQ

> [!question] `let` 和 `var` 我该用哪个？
> 默认 **`const`**，需要重新赋值时用 `let`，**基本不用 `var`**。`var` 只有两个真实用途：需要函数级提升的遗留代码、以及维护老项目。新代码里 `var` 带来的作用域泄漏与重复声明静默覆盖，几乎只会制造 bug。

> [!question] 既然 `0.1 + 0.2 !== 0.3`，JS 的数字是不是不能用？
> 能用，但要知道边界。它精确表示整数的范围是 $[-2^{53}+1, 2^{53}-1]$，做普通业务计算完全够；问题只出现在三类场景：**金额**（用整数分或 `decimal` 库）、**超大整数 ID**（用 `BigInt` 或字符串）、**需要精确相等的比较**（用误差容限）。本质上这是 IEEE 754 的性质，Python 的 `float`、C# 的 `double` 完全一样。

> [!question] `null` 和 `undefined` 我该往数据库/接口里存哪个？
> 约定比选择更重要。常见做法：**"字段不存在/未提供"用 `undefined`**（JSON 序列化时整个键消失），**"字段存在但值为空"用 `null`**（JSON 里保留 `null`）。这样前端能区分"后端没返回这个字段"和"后端明确告诉你它是空的"。

> [!question] 为什么 `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# 的类型系统对照
- [[算法-复杂度分析]] —— 本篇 $O(1)$、$O(n)$ 记号的定义与推导
- [[常见问题FAQ]] —— 跨方向的通用问题

## 参考来源

- [MDN：JavaScript 数据类型和数据结构](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Data_structures)
- [MDN：`typeof`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/typeof)
- [MDN：相等（`==`）](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Equality)
- [MDN：严格相等（`===`）](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Strict_equality)
- [MDN：`Number.isNaN()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN)
- [MDN：`Number.isSafeInteger()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger)
- [MDN：`Number.EPSILON`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON)
- [MDN：`BigInt`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
- [MDN：`Object.is()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/is)
- [MDN：空值合并运算符 `??`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- [MDN：可选链运算符 `?.`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Optional_chaining)
- [MDN：`for...of`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for...of)
- [MDN：`for...in`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for...in)
- [MDN：假值（Falsy）](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)
- [ECMAScript 语言规范（TC39 官方最新版）](https://tc39.es/ecma262/)
- [现代 JavaScript 教程：数据类型](https://zh.javascript.info/types)
- [现代 JavaScript 教程：类型转换](https://zh.javascript.info/type-conversions)
- [现代 JavaScript 教程：比较运算](https://zh.javascript.info/comparison)
- [Node.js 官方文档：Introduction to Node.js](https://nodejs.org/en/learn/getting-started/introduction-to-nodejs)
- [V8 官方博客（引擎与 JIT 优化）](https://v8.dev/blog)
