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.js | V8 | 目前生态最主流的引擎,Node.js 直接嵌入它 |
| Firefox | SpiderMonkey | 最早的 JS 引擎,Netscape 时代延续至今 |
| Safari | JavaScriptCore | 也叫 Nitro,苹果平台专用 |
| Node.js | V8 + libuv | V8 负责执行 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
| 维度 | var | let | const |
|---|---|---|---|
| 引入版本 | ES1 | ES2015 | ES2015 |
| 作用域 | 函数作用域(无视块) | 块级作用域 {} | 块级作用域 {} |
| 提升(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、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(){} | 唯一不是原始值的类型 |
// ===== 原始值 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 的区别
| 维度 | undefined | null |
|---|---|---|
| 含义 | 系统给的"没有值":变量已声明未赋值、函数无返回值、缺失的属性/参数 | 程序员主动写的"空值":明确表示"这里就是没有" |
typeof | 'undefined' | 'object'(bug) |
| 转数字 | NaN | 0 |
| 转布尔 | false | false |
| 转字符串 | '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)(全局) | true | true | true | 先 Number(x) 再判断,不可靠 |
Number.isNaN(x) | true | false | false | 只对真正的 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 + 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 |
// ===== 可运行示例:表单输入全是字符串,转换必须显式 =====
'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 | === 不区分正负零 |
结论:永远用
===
==的规则是 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 —— 跨方向的通用问题
参考来源
- MDN:JavaScript 数据类型和数据结构
- MDN:
typeof - MDN:相等(
==) - MDN:严格相等(
===) - MDN:
Number.isNaN() - MDN:
Number.isSafeInteger() - MDN:
Number.EPSILON - MDN:
BigInt - MDN:
Object.is() - MDN:空值合并运算符
?? - MDN:可选链运算符
?. - MDN:
for...of - MDN:
for...in - MDN:假值(Falsy)
- ECMAScript 语言规范(TC39 官方最新版)
- 现代 JavaScript 教程:数据类型
- 现代 JavaScript 教程:类型转换
- 现代 JavaScript 教程:比较运算
- Node.js 官方文档:Introduction to Node.js
- V8 官方博客(引擎与 JIT 优化)