BASICS / 基础篇

把语言的地基,一寸一寸打牢

基础篇不追求覆盖面,而是把每个语法点讲到底:它为什么存在、边界在哪里、什么时候会出错。 读完这一页,你应该能独立读懂一段普通的 JavaScript 代码,并写出没有歧义的表达。

4 章 · 18 个知识点 18 段可运行代码 3 个交互演示 预计 90 分钟
Chapter 01

启程:认识 JavaScript

先把运行环境、脚本加载与变量声明这三件事说清楚,后面的语法才有落脚点。

1.1

JavaScript 是什么

入门

JavaScript 是一门实现 ECMAScript 规范的高级脚本语言。规范只定义语法、类型、内置对象与执行语义,并不包含 DOM、网络请求或文件读写;这些能力由宿主环境提供:浏览器给出 window、document 与 fetch,Node.js 给出 process、fs 与 http。因此语言核心代码可以跨环境运行,而一旦调用宿主 API,就与运行环境绑定。

引擎的执行分为几个阶段:先做词法分析与语法分析,把源码转换为抽象语法树;随后由解释器快速生成并执行字节码,同时收集类型反馈;对反复执行的热点函数,JIT 编译器会把字节码编译为机器码,并做内联、去虚拟化等优化。若运行时的实际类型与优化假设不符,引擎会回退到解释执行,这就是所谓的反优化。

浏览器中的 JavaScript 运行在主线程上,同一时刻只有一个调用栈在工作。定时器、用户事件与网络响应由宿主调度,完成后把回调排入队列,再由事件循环送回主线程。因此一段长时间的同步计算会阻塞渲染与交互,这也是后续要学习异步与任务拆分的原因。

ECMAScript 规范

定义语法、类型、内置对象与执行语义,是所有引擎共同遵守的契约。

JavaScript 引擎

如 V8、SpiderMonkey、JavaScriptCore,负责解析、解释与 JIT 编译。

宿主环境

浏览器与 Node.js 提供 DOM、网络、文件等规范之外的能力。

下面的代码可以在浏览器或 Node.js 中直接运行,用于识别当前环境并观察一段简单循环:

// 同一段 JS,在不同宿主环境中拿到的全局对象不同
// 浏览器:window 上有 DOM、BOM 与 Web API
// Node.js:global 上有 process、fs、http,但没有 DOM

function detectRuntime() {
  if (typeof window !== 'undefined' && typeof document !== 'undefined') {
    return '浏览器';
  }
  if (typeof process !== 'undefined' && process.versions && process.versions.node) {
    return 'Node.js ' + process.versions.node;
  }
  return '未知环境';
}

const runtime = detectRuntime();
console.log('当前运行环境:', runtime);

// 引擎执行流程:源码 → 词法/语法分析 → AST
// → 解释器快速执行 → 热点代码交给 JIT 编译优化
const hot = [];
for (let i = 0; i < 100000; i++) {
  hot.push(i * 2); // 反复执行的循环体更容易被 JIT 优化
}
console.log('数组长度:', hot.length);

JIT 并不是把全部代码一次性编译成机器码。引擎先用解释器快速启动,只对反复执行的热点函数做优化编译;当对象形状变化或参数类型不再稳定时,优化代码会被丢弃,回到解释执行。这也是为什么保持函数参数类型稳定、对象结构一致,通常能获得更好的性能。

1.2

如何引入脚本

入门

浏览器解析 HTML 时,如果遇到没有 defer 或 async 的外部脚本,会暂停 DOM 构建,先下载并执行脚本,执行完再继续解析。因此把脚本放在 head 中会推迟首屏呈现;放在 body 末尾则能让 DOM 先构建完成,脚本随后执行。

defer 与 async 都只对外部脚本生效,并且下载过程与解析并行。defer 保证脚本在文档解析完成后、DOMContentLoaded 之前按出现顺序执行;async 则是下载完成就立即执行,多个脚本的先后顺序无法保证,还可能早于 DOM 就绪。存在依赖关系时用 defer,独立的统计或埋点脚本可以用 async。

内联脚本没有 src,写 defer 或 async 不会生效。开发阶段最直接的观察手段是 console:log 支持占位符,group 可以折叠一组输出,table 适合查看数组与对象的结构。先确认脚本确实执行了,再排查逻辑,能省下大量时间。

// 推荐:脚本放在 body 末尾,或使用 defer
// <script src="app.js" defer></script>

// 第一个程序:向控制台输出信息
console.log('Hello, JavaScript');

// console 不只是 log
console.info('普通信息');
console.warn('这是一条警告');
console.error('这是一条错误');

// 用占位符组织输出,比字符串拼接更清晰
const name = '拾光';
const lessons = 18;
console.log('%s 共有 %d 个知识点', name, lessons);

// 分组输出,适合打印一组相关数据
console.group('学习进度');
console.log('基础篇:进行中');
console.log('进阶篇:未开始');
console.groupEnd();

// 表格输出,直观查看结构化数据
console.table([
  { 章节: '第一章', 主题: '认识 JavaScript' },
  { 章节: '第二章', 主题: '运算符与流程控制' }
]);

defer 与 async 只对外部脚本生效。给内联脚本加上这两个属性不会改变执行时机;此外,动态创建的 script 元素默认行为类似 async,需要按顺序执行时应显式把 async 设为 false。

1.3

变量声明 var / let / const

基础

var 是函数作用域,声明会提升到函数顶部并初始化为 undefined,所以在声明语句之前访问得到的是 undefined。let 与 const 是块级作用域,声明同样会提升,但不会初始化;从进入作用域到声明语句之间称为暂时性死区(TDZ),此时访问会抛出 ReferenceError。TDZ 的价值在于让「先用后声明」尽早暴露成错误。

let 允许重新赋值,const 约束的是绑定而非值:基本类型不能再指向别的值,对象的属性却仍可修改。只有 Object.freeze 才能让对象属性不可写,而且只冻结第一层。在 for 循环中使用 let,每一轮都会创建独立绑定,配合闭包可以得到预期结果;使用 var 时所有回调共享同一个变量。

命名使用小驼峰:变量与函数用名词或动宾短语,布尔值以 is、has、can 开头,常量可用全大写。避免 a、temp1 这类无法表达意图的名字。声明时优先 const,确实需要修改再换成 let,不要使用 var。

// 1. var 没有块级作用域,声明会提升并初始化为 undefined
console.log(a); // undefined
var a = 1;

// 2. let / const 有块级作用域,声明前访问会进入暂时性死区
try {
  console.log(b); // 抛出 ReferenceError
} catch (err) {
  console.log('访问 b 失败:', err.name); // ReferenceError
}
let b = 2;

// 3. 块级作用域:循环结束后 i 不可见
for (let i = 0; i < 3; i++) {
  // 每一轮都有独立的 i
}
try {
  console.log(i);
} catch (err) {
  console.log('循环外访问 i:', err.name); // ReferenceError
}

// 4. const 禁止重新赋值,但不冻结对象内部
const user = { name: '小林' };
user.name = '小周'; // 允许:修改的是对象属性
console.log(user.name);
try {
  user = {}; // 抛出 TypeError
} catch (err) {
  console.log('重新赋值失败:', err.name);
}
对比项varletconst
作用域函数作用域块级作用域块级作用域
声明提升提升并初始化为 undefined提升但不初始化(TDZ)同 let
重复声明允许同一作用域内禁止禁止
重新赋值允许允许禁止,对象属性仍可修改
声明时初始化不要求不要求必须

声明时先写 const,确实需要重新赋值时再改成 let。这样读代码的人一眼就能知道哪些绑定会变化。对象用 const 声明并不表示内容不可变,只是不能把变量指向另一个对象。

1.4

数据类型全景

入门

JavaScript 有七种原始类型:undefined、null、boolean、number、string、symbol、bigint,除此之外的值都是对象,包括数组、函数、日期与正则。原始值按值比较且不可变,对象按引用比较,变量里保存的是指向堆内存的地址。

number 采用 IEEE 754 双精度浮点表示,安全整数范围是正负 2 的 53 次方减一,超出后整数精度会丢失,此时应使用 bigint。0.1 加 0.2 不等于 0.3 是二进制无法精确表示十进制小数导致的,不是语言缺陷。symbol 每次调用都会创建唯一值,常作为对象属性键,避免命名冲突。

typeof 返回一个字符串,但有两个历史遗留:typeof null 得到 object,因为早期实现用低位类型标签标识对象;typeof 函数得到 function,而函数本质上是可调用对象。判断数组使用 Array.isArray,判断 null 直接用全等比较,判断普通对象则要排除 null 与数组。

string number boolean undefined null symbol bigint object
// 七种原始类型
const s = '文本';              // string
const n = 42;                  // number
const bool = true;             // boolean
const u = undefined;           // undefined
const empty = null;            // null
const sym = Symbol('id');      // symbol
const big = 9007199254740993n; // bigint

// 引用类型
const obj = { s, n, bool, u, empty, sym, big };
const arr = [1, 2, 3];
const fn = function () {};

// typeof 的返回值
console.log(typeof s);      // string
console.log(typeof n);      // number
console.log(typeof bool);   // boolean
console.log(typeof u);      // undefined
console.log(typeof sym);    // symbol
console.log(typeof big);    // bigint

// 三个容易被问到的地方
console.log(typeof null);        // object(历史遗留问题)
console.log(typeof arr);         // object,数组需要 Array.isArray
console.log(typeof fn);          // function
console.log(Array.isArray(arr)); // true

// Symbol 每次调用都产生唯一值
console.log(Symbol('id') === Symbol('id')); // false
值typeof 结果说明
'文本'string原始类型,不可变
42number双精度浮点数,包含 NaN 与 Infinity
trueboolean只有 true 与 false 两个值
undefinedundefined声明未赋值时的默认值
nullobject历史遗留,判断应使用全等比较
Symbol('id')symbol每次创建都是唯一值
10nbigint任意精度整数,不能与 number 直接混算
{}object数组、日期、正则同属 object
function () {}function可调用对象,typeof 单独返回 function

访问原始值的属性时,引擎会临时创建一个包装对象,读取完立即销毁,这叫装箱。所以 'abc'.length 可以工作,但给原始值添加属性不会保留。日常不需要手动 new String 或 new Number,它们会创建对象,容易在比较时产生意外结果。

1.5

类型转换与相等

基础

显式转换使用 Number、String、Boolean、parseInt 等函数,意图清楚,应优先采用。Number 对空字符串返回 0,对无法整体解析的字符串返回 NaN;parseInt 则从开头逐字符解析,遇到非法字符停止,所以 parseInt('12px', 10) 得到 12。布尔转换中只有八个假值:false、0、-0、0n、空字符串、null、undefined、NaN,其余都是真值。

隐式转换由运算符触发:加号只要有一侧是字符串就执行拼接,其余算术运算符一律转为数值;关系比较在类型不同时也会转换。双等号执行抽象相等比较,规则繁多且容易误判,工程中统一使用三等号。唯一值得保留双等号的场景是与 null 比较,可同时匹配 null 与 undefined。

NaN 表示无效数值,它与任何值包括自身都不相等,因此不能用相等判断。Number.isNaN 只对真正的 NaN 返回 true,全局 isNaN 会先做类型转换,容易把字符串误判为 NaN。Object.is 与三等号基本一致,但把 NaN 视为相等、把正零与负零视为不等,适合需要精确区分的场合。

// 显式转换:意图明确,推荐优先使用
console.log(Number('42'));         // 42
console.log(Number('42px'));       // NaN
console.log(parseInt('42px', 10)); // 42,从头解析到第一个非法字符
console.log(String(42));           // '42'
console.log(Boolean(''));          // false
console.log(Boolean('0'));         // true,非空字符串都是真值

// 隐式转换:由运算符触发
console.log('5' + 1);   // '51',+ 遇到字符串转为拼接
console.log('5' - 1);   // 4,- 只做数值运算
console.log('5' * '2'); // 10
console.log(1 + true);  // 2,true 转成 1

// == 会先做类型转换,=== 不转换
console.log(1 == '1');   // true
console.log(1 === '1');  // false
console.log(null == undefined);  // true
console.log(null === undefined); // false

// NaN 的特殊性
console.log(NaN === NaN);         // false
console.log(Number.isNaN(NaN));   // true
console.log(Object.is(NaN, NaN)); // true

// Object.is 与 === 只有两处不同
console.log(Object.is(0, -0)); // false
console.log(0 === -0);         // true
交互演示 · 类型转换实验输入任意内容
结果会显示在这里。
表达式结果原因
Number('')0空字符串按数值解析为 0
Number('12px')NaN整体无法解析为数值
parseInt('12px', 10)12逐字符解析,遇到非数字停止
'5' + 1'51'加号遇到字符串转为拼接
'5' - 14减号只做数值运算
Boolean('0')true非空字符串都是真值
null == undefinedtrue抽象相等比较的特殊规则
NaN === NaNfalseNaN 与任何值都不相等

双等号的转换规则包括:null 只与 undefined 相等;布尔值先转数字;字符串与数字比较时转数字;对象与原始值比较时调用其 valueOf 或 toString。记住这些规则的成本远高于统一使用三等号,因此除了判断 null 或 undefined,其他场景都应使用三等号。

Chapter 02

运算符与流程控制

运算符决定表达式如何求值,分支与循环决定代码如何流动,异常处理决定出错时如何收场。

2.1

运算符全览

基础

算术运算符包括加减乘除、取余与幂运算,其中加号同时承担字符串拼接,结果由操作数类型决定。比较运算符中,双等号会先转换类型,三等号不转换;关系运算符在两侧都是字符串时按 UTF-16 码元逐位比较,而不是按字典或长度。

逻辑运算符的返回值是操作数本身,而非布尔值:a 或 b 在 a 为假值时返回 b,a 且 b 在 a 为真值时返回 b。这带来短路求值:右侧表达式在无需计算时不会执行,可用于提供默认值、条件调用与参数守卫。

空值合并运算符只在左侧为 null 或 undefined 时取右侧,因此能保留 0、空字符串与 false 这些合法值;可选链在中间值为 null 或 undefined 时整体返回 undefined,避免逐层判断。注意空值合并不能与逻辑与、逻辑或无括号混用,否则是语法错误。三元表达式适合简单的二选一,嵌套过深时应改用 if 或映射表。

// 算术与幂运算
console.log(7 % 3);   // 1,取余
console.log(2 ** 10); // 1024,幂运算

// 比较:== 会转换类型,=== 不会
console.log(0 == false);  // true
console.log(0 === false); // false

// 逻辑运算符会返回操作数本身,而不是布尔值
const nickname = '' || '匿名用户';
const saved = 0 ?? 10; // ?? 只处理 null / undefined
console.log(nickname); // '匿名用户'
console.log(saved);    // 0

// 短路求值:左侧已能决定结果时,右侧不会执行
let calls = 0;
function touch() { calls++; return true; }
false && touch();
true || touch();
console.log(calls); // 0

// 可选链:中间为 null / undefined 时整体返回 undefined
const user = { profile: { city: '杭州' } };
console.log(user.profile?.city);  // '杭州'
console.log(user.account?.email); // undefined,不报错

// 三元表达式
const age = 20;
const label = age >= 18 ? '成年' : '未成年';
console.log(label);

空值合并运算符不能与逻辑与、逻辑或直接混用。表达式 a || b ?? c 会抛出 SyntaxError,必须写成 (a || b) ?? c 或 a || (b ?? c)。这样设计是为了强制开发者明确优先级,避免误读。

2.2

条件分支

入门

if 与 else if 自上而下判断,条件为真就执行对应分支并跳过其余分支。把最可能命中的条件放在前面可以减少比较次数;复杂条件应提取成具名布尔变量,让判断意图直接可读。

switch 使用全等比较,case 只是跳转标签。如果分支末尾没有 break,控制流会继续执行下一个分支,这叫穿透;多个值共用同一段逻辑时可以故意省略 break,但漏写也是常见错误。default 可以放在任意位置,通常放在最后作为兜底。

三元表达式适合把二选一的结果直接赋给变量,例如根据分数给出及格与否。它不适合承载多条语句,也不适合三层以上嵌套;当分支变多时,if 链或对象映射表更容易维护。

// if / else if / else:按顺序判断,命中即止
function grade(score) {
  if (score >= 90) return 'A';
  else if (score >= 80) return 'B';
  else if (score >= 60) return 'C';
  return 'D';
}
console.log(grade(85)); // B

// switch 使用全等比较,default 可以放在任意位置
function daysInMonth(month, year) {
  switch (month) {
    case 2:
      // 闰年:能被 4 整除且不能被 100 整除,或能被 400 整除
      return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0 ? 29 : 28;
    case 4:
    case 6:
    case 9:
    case 11:
      return 30; // 穿透:共用同一个分支
    default:
      return 31;
  }
}
console.log(daysInMonth(2, 2024));  // 29
console.log(daysInMonth(11, 2025)); // 30

// 三元适合简单二选一;嵌套过深时应改回 if 或查表
const level = 3;
const title = level === 1 ? '入门' : level === 2 ? '熟悉' : '熟练';
console.log(title);

switch 中故意穿透时,建议加一行注释说明「此处故意不写 break」,否则后来维护的人很难判断这是设计还是遗漏。每个 case 都以 return 结束时,就不再需要 break。

2.3

循环

基础

for 适合次数已知的循环,初始化、条件与更新三个部分集中在一行;while 适合由条件驱动、次数未知的场景;do...while 先执行一次再判断,至少执行一轮。三者都可以用 break 立即结束整个循环,用 continue 跳过本轮剩余语句。

for...of 遍历可迭代对象的值,数组、字符串、Map 与 Set 都可用;for...in 遍历对象的可枚举属性键,包括原型链上的属性,而且键是字符串。遍历数组应使用 for...of 或数组方法,不要用 for...in,因为它可能枚举到额外属性。

标签语句可以给循环命名,让 break 或 continue 作用于外层循环,适合在二维遍历中提前退出。循环体内修改被遍历数组的长度,可能导致元素被跳过或循环无法结束,应在遍历前确定范围。

// for:适合已知循环次数
let sum = 0;
for (let i = 1; i <= 5; i++) {
  sum += i;
}
console.log('1 到 5 的和:', sum); // 15

// while:适合条件驱动的循环
let n = 1;
while (n < 100) {
  n *= 2;
}
console.log('第一个不小于 100 的 2 的幂:', n); // 128

// do...while:至少执行一次
let count = 0;
do {
  count++;
} while (count < 0);
console.log(count); // 1

// for...of 遍历值;for...in 遍历键(包含可枚举的继承属性)
const fruits = ['苹果', '梨', '桃'];
for (const fruit of fruits) {
  console.log(fruit);
}
for (const index in fruits) {
  console.log(index, typeof index); // '0' '1' '2',注意是字符串
}

// 标签语句配合 break 跳出外层循环
outer:
for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 3; j++) {
    if (i === 1 && j === 2) break outer;
    console.log(i, j);
  }
}
交互演示 · 循环输出观察每一轮
点击「运行循环」查看结果。

不要用 for...in 遍历数组。它枚举的是属性键,键是字符串,还可能包含原型链或手动添加的属性,顺序也不保证。遍历数组用 for...of 取得值,需要索引时用 for 或 entries。

2.4

异常处理

基础

运行时错误会中断当前执行流。try 包裹可能出错的代码,catch 捕获同步异常,finally 无论是否发生异常都会执行,常用于关闭连接、释放锁或清理临时状态。catch 的参数在较新的规范中可以省略。

throw 可以抛出任意值,但应抛出 Error 实例或其子类,才能保留调用栈。常见内置错误包括 SyntaxError、ReferenceError、TypeError 与 RangeError,分别对应解析失败、访问未声明变量、类型不匹配与数值越界。

错误优先原则要求:能预判的非法输入应尽早抛出,而不是返回一个含义模糊的默认值;捕获之后要么处理并恢复,要么补充上下文再抛出,不要静默吞掉。同步的 try 捕获不到异步回调里的异常,异步错误要在 Promise 或 async 函数内部处理。

// 主动抛出错误,让问题在源头暴露
function divide(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new TypeError('参数必须是数字');
  }
  if (b === 0) {
    throw new RangeError('除数不能为 0');
  }
  return a / b;
}

// finally 无论是否异常都会执行,常用于释放资源
function run() {
  try {
    console.log('结果:', divide(10, 2));
    console.log('结果:', divide(10, 0));
  } catch (err) {
    console.log('捕获到:', err.name, err.message);
  } finally {
    console.log('本次计算结束');
  }
}
run();

// 自定义错误:继承 Error,便于上层按类型区分
class ValidationError extends Error {
  constructor(field) {
    super('字段校验失败:' + field);
    this.name = 'ValidationError';
    this.field = field;
  }
}

try {
  throw new ValidationError('email');
} catch (err) {
  if (err instanceof ValidationError) {
    console.log('处理校验错误:', err.field);
  }
}

空的 catch 块会吞掉错误,让问题在更远的地方以更难排查的方式出现。至少记录错误,或在补充上下文后重新抛出。不要把业务逻辑全部塞进 finally,它的职责只是清理。

Chapter 03

函数

函数是 JavaScript 的基本复用单元,也是理解 this、闭包与高阶抽象的第一步。

3.1

函数声明与函数表达式

基础

函数声明会被完整提升,因此可以在声明语句之前调用。函数表达式把函数赋给变量,提升的只是变量声明,赋值发生在执行到那一行时;在赋值前调用会得到 TypeError,因为变量此时是 undefined。

默认参数只在实参为 undefined 时生效,传 null 不会触发;默认值可以是表达式,也可以引用前面的参数。剩余参数把多余实参收集为真正的数组,必须放在参数列表末尾,之后不能再有普通参数。

arguments 是函数内部的类数组对象,保存全部实参,有 length 与索引,但没有数组方法;箭头函数没有自己的 arguments。现代代码更推荐剩余参数,因为它本身就是数组,语义也更明确。

// 函数声明会整体提升,可以在声明前调用
console.log(add(2, 3)); // 5
function add(a, b) {
  return a + b;
}

// 函数表达式赋给变量,提升的是变量本身
try {
  console.log(sub(5, 2));
} catch (err) {
  console.log('调用失败:', err.name); // TypeError
}
var sub = function (a, b) {
  return a - b;
};

// 默认参数:传入 undefined 时生效,传 null 不会
function greet(name = '同学', punctuation = '。') {
  return '你好,' + name + punctuation;
}
console.log(greet());          // 你好,同学。
console.log(greet('小林'));     // 你好,小林。
console.log(greet('小林', '!'));

// 剩余参数:收集为真正的数组
function total(first, ...rest) {
  return rest.reduce((acc, cur) => acc + cur, first);
}
console.log(total(1, 2, 3, 4)); // 10

// arguments 是类数组对象,箭头函数中没有
function legacy() {
  console.log(arguments.length, Array.isArray(arguments)); // 2 false
}
legacy('a', 'b');
对比项函数声明函数表达式
提升行为函数整体提升,可在声明前调用只提升变量,赋值前调用报 TypeError
函数名必须具名可匿名,也可具名便于调试
适用场景顶层工具函数回调、按条件创建、模块内部私有函数

默认参数与解构可以组合,例如 function create({ name = '匿名', age = 0 } = {})。末尾的 = {} 很关键,它保证调用时不传参数也不会因为解构 undefined 而报错。

3.2

箭头函数与普通函数的核心差异

进阶

箭头函数没有自己的 this,它在定义时捕获外层作用域的 this,因此适合用作回调、定时器与数组方法的参数。普通函数的 this 由调用方式决定,可能是 undefined、全局对象、调用者对象或新创建的实例。

箭头函数没有 arguments 与 prototype,不能作为构造函数,使用 new 会抛 TypeError,也不能声明为 generator。由于 this 是词法绑定的,call、apply、bind 无法改变它,这一点在需要动态接收者的场景中必须注意。

箭头函数直接返回对象字面量时,必须用圆括号把对象包起来,否则花括号会被解析为函数体。对象方法、需要访问调用者、需要被继承或实例化的函数,应使用普通函数或方法简写。

const counter = {
  count: 0,
  start() {
    // 普通函数的 this 由调用方式决定
    console.log('普通函数 this.count:', this.count);

    // 箭头函数没有自己的 this,继承外层 start 的 this
    setTimeout(() => {
      this.count++;
      console.log('一秒后 count:', this.count);
    }, 1000);

    // 如果用普通函数,this 指向 window(非严格模式)
    setTimeout(function () {
      console.log('普通回调 this === window:', this === window);
    }, 0);
  }
};
counter.start();

// 箭头函数不能作为构造函数
const Arrow = () => {};
try {
  new Arrow();
} catch (err) {
  console.log('new 箭头函数:', err.name); // TypeError
}

// 返回对象字面量需要额外括号,否则 {} 被当作函数体
const makeUser = (name) => ({ name, active: true });
console.log(makeUser('小满'));

// 箭头函数没有 arguments
const noArgs = () => {
  // console.log(arguments); // ReferenceError
  return '没有 arguments';
};
console.log(noArgs());

普通函数的 this 有四条绑定规则:new 绑定优先于显式绑定,显式绑定优先于隐式绑定,隐式绑定优先于默认绑定;箭头函数不参与这套规则,它直接使用定义位置的 this。class 方法内部的 this 也是动态的,作为回调传递时同样可能丢失。

3.3

回调函数与高阶函数初识

基础

函数是一等公民:可以赋给变量、作为参数传入、作为返回值返回。把函数作为参数传给另一个函数,这个被传入的函数就是回调;接收函数或返回函数的函数称为高阶函数。数组的 map、filter、reduce 都是典型的高阶函数。

回调的参数由调用方决定:map 依次传入元素、索引与原数组,事件监听传入事件对象。理解回调签名,才能正确使用这些接口,也能在需要时手写一个功能相同的实现。

回调可以是同步的,也可以是异步的。同步回调在调用返回前执行完毕,结果立即可用;异步回调要等到定时器到期、网络响应到达才执行。异步回调的控制流正是后续 Promise 与 async/await 要解决的问题。

// 函数是一等公民:可以赋值、传参、返回
function repeat(times, action) {
  for (let i = 0; i < times; i++) {
    action(i);
  }
}
repeat(3, (i) => console.log('第', i + 1, '次'));

// 高阶函数:接收函数或返回函数
function multiplier(factor) {
  return function (value) {
    return value * factor;
  };
}
const double = multiplier(2);
console.log(double(21)); // 42

// 手写一个 map,理解回调如何被调用
function map(array, callback) {
  const result = [];
  for (let i = 0; i < array.length; i++) {
    result.push(callback(array[i], i, array));
  }
  return result;
}
const prices = [12, 30, 45];
const withTax = map(prices, (price) => +(price * 1.06).toFixed(2));
console.log(withTax); // [12.72, 31.8, 47.7]

// 回调的同步执行:map 返回时结果已经就绪
console.log('长度:', withTax.length);

判断一个函数是不是高阶函数,只看它是否接收函数或返回函数,与函数内部做什么无关。把重复的循环逻辑抽成高阶函数,是消除重复代码最直接的方式。

3.4

递归

进阶

递归是函数直接或间接调用自身,必须同时具备出口与规模缩小两个条件,否则会无限调用直到栈溢出,抛出 RangeError。每次调用都会创建新的执行上下文并压入调用栈,栈的深度有限,因此递归层数不能太深。

阶乘、斐波那契、树结构遍历都适合用递归表达。朴素递归可能重复计算相同子问题,可以用缓存或记忆化优化,也可以改写为迭代。规范并未强制引擎实现尾递归优化,不应依赖它来避免栈溢出。

深拷贝是递归的经典应用:原始值直接返回,数组与对象创建同类型容器,记录已访问对象以处理循环引用,再逐键递归复制。手写递归无法覆盖函数、Symbol 键、Map、Set 等特殊对象,现代环境可优先使用 structuredClone。

// 递归三要素:出口、规模缩小、调用自身
function factorial(n) {
  if (n <= 1) return 1;        // 出口
  return n * factorial(n - 1); // 规模每次减 1
}
console.log(factorial(5)); // 120

// 深拷贝:递归处理数组与普通对象,用 WeakMap 解决循环引用
function deepClone(value, seen = new WeakMap()) {
  if (value === null || typeof value !== 'object') return value;
  if (seen.has(value)) return seen.get(value);

  const copy = Array.isArray(value) ? [] : {};
  seen.set(value, copy);

  for (const key of Object.keys(value)) {
    copy[key] = deepClone(value[key], seen);
  }
  return copy;
}

const source = { name: '书单', list: [1, 2], meta: { owner: '小林' } };
source.self = source; // 循环引用
const cloned = deepClone(source);
console.log(cloned.self === cloned);       // true
console.log(cloned.meta === source.meta);  // false

// 没有出口的递归会耗尽调用栈
function infinite() { return infinite(); }
try {
  infinite();
} catch (err) {
  console.log('栈溢出:', err.name); // RangeError
}

现代浏览器与 Node.js 提供结构化克隆 structuredClone,可复制 Date、Map、Set、RegExp 与循环引用,但不能复制函数与 DOM 节点。它比 JSON 往返更可靠,也比手写递归更省心。

Chapter 04

数组、对象与数据

数组与对象承载了绝大多数业务数据,方法选得对,代码会短一半,也更容易读。

4.1

数组基础操作

入门

数组是有序集合,索引从 0 开始,length 可读可写。push 与 pop 在尾部增删,unshift 与 shift 在头部增删;头部操作需要移动后续元素的索引,数据量大时性能低于尾部操作。

slice 按下标截取片段并返回浅拷贝,不修改原数组,结束下标不包含在内。splice 直接修改原数组,第二个参数是删除个数,之后的参数会插入到删除位置,返回值是被删除元素组成的数组,因此它既能删除也能替换和插入。

includes 使用 SameValueZero 比较,能正确判断 NaN 是否存在;indexOf 使用严格相等,对 NaN 始终返回负一。join 用指定分隔符把元素拼成字符串。展开运算符与 concat 都能合并数组,但都只复制第一层。

const stack = ['a', 'b'];

// 尾部操作
stack.push('c');          // 末尾添加,返回新长度
console.log(stack);       // ['a', 'b', 'c']
console.log(stack.pop()); // 'c',删除并返回末尾元素

// 头部操作,性能低于尾部,因为要移动索引
stack.unshift('z');       // 头部添加,返回新长度
console.log(stack);       // ['z', 'a', 'b']
console.log(stack.shift()); // 'z'

// slice 不修改原数组,splice 会修改
const nums = [1, 2, 3, 4, 5];
console.log(nums.slice(1, 4)); // [2, 3, 4]
console.log(nums);             // 原数组不变

const removed = nums.splice(1, 2, 'x', 'y');
console.log(removed); // [2, 3]
console.log(nums);    // [1, 'x', 'y', 4, 5]

// includes 能正确判断 NaN,indexOf 不能
const values = [1, NaN];
console.log(values.includes(NaN)); // true
console.log(values.indexOf(NaN));  // -1

// join 把数组拼成字符串
console.log(['2026', '11', '16'].join('-')); // 2026-11-16

// 浅拷贝的几种写法
const copy = [...nums];
console.log(copy === nums); // false
方法作用是否修改原数组
push / pop尾部添加 / 删除一个元素是
unshift / shift头部添加 / 删除一个元素是
slice(start, end)截取片段,返回浅拷贝否
splice(start, count, ...items)删除、插入或替换是
includes / indexOf判断是否存在 / 查找下标否
join(separator)拼接为字符串否
sort(compareFn)原地排序是
concat / 展开运算符合并数组,浅拷贝否

判断一个方法是否修改原数组,可以看它的返回值语义:slice、concat、map、filter 返回新数组;push、pop、splice、sort、reverse 修改原数组。

4.2

遍历与转换

进阶

map 一一映射,返回长度相同的新数组;filter 保留回调返回真值的元素;find 返回第一个匹配项,没有则返回 undefined;some 与 every 返回布尔值,分别表示存在满足项与全部满足。它们都不会修改原数组。

reduce 把数组折叠为一个值,回调依次接收累加器、当前值、当前索引与原数组,第二个实参是累加器的初始值。省略初始值时,第一个元素会成为初始累加器,空数组调用会抛 TypeError。由于初始值类型自由,reduce 也能完成分组、计数与扁平化。

sort 原地排序并返回原数组,默认把元素转为字符串比较,所以数字排序必须传入比较函数。flat 按指定深度展平嵌套数组,Infinity 表示任意深度。链式调用时要留意哪些方法修改了原数组,避免后续步骤读到意外状态。

const orders = [
  { id: 1, amount: 120, status: 'paid' },
  { id: 2, amount: 80, status: 'pending' },
  { id: 3, amount: 200, status: 'paid' }
];

// map:一一映射,返回等长新数组
const ids = orders.map((order) => order.id);
console.log(ids); // [1, 2, 3]

// filter:保留回调为真值的元素
const paid = orders.filter((order) => order.status === 'paid');
console.log(paid.length); // 2

// find:返回第一个匹配项,没有则 undefined
console.log(orders.find((order) => order.id === 2).amount); // 80

// some / every:判断是否存在 / 是否全部满足
console.log(orders.some((order) => order.amount > 150));  // true
console.log(orders.every((order) => order.amount > 100)); // false

// reduce:把数组折叠成一个值
// 参数:累加器、当前值、当前索引、原数组;第二个实参是初始值
const total = orders.reduce((acc, order, index) => {
  console.log('第', index + 1, '轮,累加器当前为', acc);
  return acc + order.amount;
}, 0);
console.log('总金额:', total); // 400

// sort 会修改原数组,并且默认按字符串排序
const nums = [10, 2, 33, 4];
console.log(nums.sort());            // [10, 2, 33, 4] 的字符串顺序
console.log([...nums].sort((a, b) => a - b)); // [2, 4, 10, 33]

// flat 展平嵌套数组
console.log([1, [2, [3]]].flat(Infinity)); // [1, 2, 3]
交互演示 · reduce 累加器逐步展开
输入数字后点击「开始折叠」。

sort 默认按字符串比较,[10, 2, 1].sort() 会得到 [1, 10, 2]。数字排序必须传 (a, b) => a - b,且 sort 会原地修改数组,不希望改动原数据时先复制一份。

用 reduce 分组:累加器初始化为空对象,回调中按 key 建数组并 push 当前项。因为初始值与元素类型可以不同,reduce 能表达求和之外的大量聚合逻辑,但可读性不如专用方法时不要强行使用。

4.3

对象基础

基础

对象是键值对的集合,键只能是字符串或 Symbol。点访问要求键是合法标识符且书写时已知;方括号接受任意表达式,适合动态键名,也适合包含空格或连字符的键。

新增与修改都直接赋值,删除使用 delete。访问不存在的属性得到 undefined,判断属性是否存在时,in 会检查原型链,Object.hasOwn 只检查对象自身。Object.keys、values、entries 返回自身可枚举属性,常与数组方法配合完成遍历与转换。

展开运算符与 Object.assign 都是浅拷贝,只复制第一层,嵌套对象仍共享引用。Object.freeze 让对象无法增删改属性,但同样只作用于第一层;需要彻底不可变时要递归冻结。冻结失败在非严格模式下是静默的,严格模式才会抛出 TypeError。

const book = {
  title: 'JavaScript 高级程序设计',
  year: 2020,
  tags: ['前端', '编程']
};

// 点访问适合固定属性名,方括号适合动态键名
console.log(book.title);
const key = 'year';
console.log(book[key]); // 2020

// 增、改、删
book.author = 'Nicholas'; // 新增
book.year = 2024;         // 修改
delete book.tags;         // 删除
console.log(book);

// 判断属性是否存在,in 会检查原型链
console.log('author' in book);                // true
console.log('toString' in book);              // true,来自 Object.prototype
console.log(Object.hasOwn(book, 'toString')); // false

// 遍历键值对
console.log(Object.keys(book));    // ['title', 'year', 'author']
console.log(Object.values(book));  // 对应的值
console.log(Object.entries(book)); // [[键, 值], ...]

// Object.assign 与展开运算符都是浅拷贝
const copy = Object.assign({}, book);
const copy2 = { ...book };
console.log(copy === book); // false

// Object.freeze 只冻结第一层
Object.freeze(book);
book.year = 1999;       // 静默失败(非严格模式)
console.log(book.year); // 2024

展开运算符、Object.assign 与数组的 slice 都是浅拷贝。复制后修改嵌套对象,原对象也会变化。Object.freeze 同样只冻结第一层,嵌套对象不受影响。

4.4

字符串、数字与日期

基础

模板字符串使用反引号,支持插值、多行文本与任意表达式,避免了大量字符串拼接。字符串不可变,所有方法都返回新字符串:trim 去掉首尾空白,includes 判断子串,split 按分隔符拆分,slice 截取片段,padStart 补齐长度。

Math 提供 round、floor、ceil、max、min 与 random 等静态方法。random 返回大于等于 0 且小于 1 的小数,生成闭区间整数需要先用区间长度相乘再取整。浮点数无法精确表示所有小数,金额计算通常转换为整数分,或使用专门的十进制库。

Date 内部保存的是毫秒时间戳,Date.now 返回当前时间戳,new Date(0) 对应 1970 年 1 月 1 日零点。getMonth 从 0 开始、getDay 以周日为 0,是最容易写错的地方。面向用户的日期与货币格式应交给 Intl.DateTimeFormat 与 Intl.NumberFormat。

// 模板字符串:支持插值、多行与表达式
const user = { name: '小林', score: 92 };
console.log(`${user.name} 的得分是 ${user.score},${user.score >= 60 ? '及格' : '不及格'}`);

// 常用字符串方法
const text = '  JavaScript 基础  ';
console.log(text.trim());         // 去掉首尾空白
console.log(text.includes('Script')); // true
console.log('a,b,c'.split(','));  // ['a', 'b', 'c']
console.log('abc'.padStart(5, '0')); // 00abc
console.log('Hello'.slice(1, 4)); // ell
console.log('abcabc'.replaceAll('a', 'x')); // xbcxbc

// Math:常用数学运算
console.log(Math.round(4.5));   // 5
console.log(Math.floor(4.9));   // 4
console.log(Math.ceil(4.1));    // 5
console.log(Math.max(1, 9, 4)); // 9
console.log(Math.random());     // [0, 1) 之间的随机数

// 随机整数:闭区间 [min, max]
function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(randomInt(1, 6));

// Date 与时间戳
const now = new Date();
console.log(now.toISOString());
console.log(Date.now()); // 毫秒时间戳
console.log(new Date(0).toISOString()); // 1970-01-01T00:00:00.000Z

// Intl 负责本地化格式,避免手写拼接
console.log(new Intl.DateTimeFormat('zh-CN').format(now));
console.log(new Intl.NumberFormat('zh-CN', { style: 'currency', currency: 'CNY' }).format(1234.5));

Date 的解析在不同引擎与不同格式下曾存在差异,跨端传输时间请使用 ISO 8601 字符串或毫秒时间戳,再在展示层用 Intl 格式化,避免依赖本地时区的隐式解析。

4.5

JSON 与序列化

深入

JSON 是一种文本数据格式,只支持对象、数组、字符串、数字、布尔值与 null。对象的键必须使用双引号,不能写注释,也不能有尾逗号。JSON.stringify 把值转成字符串,JSON.parse 把字符串还原为值,二者是前后端交换数据的基础。

stringify 会忽略值为 undefined、函数与 Symbol 的属性,数组中的这些值则变成 null;Date 会被转成 ISO 字符串,NaN 与 Infinity 变成 null。第二个参数 replacer 可以是函数或属性白名单,第三个参数控制缩进空格数。

parse 的第二个参数 reviver 会在返回最终结果前逐个处理键值,可把日期字符串还原为 Date。存在循环引用时 stringify 会抛 TypeError。JSON 往返会丢失类型信息,所以它不是通用深拷贝:Map、Set、RegExp、函数与 undefined 都无法保留,需要时使用 structuredClone。

const order = {
  id: 1001,
  items: [{ name: '笔记本', price: 25 }],
  createdAt: new Date('2026-11-16T08:00:00Z'),
  remark: undefined
};

// 序列化:undefined、函数、Symbol 会被忽略
const json = JSON.stringify(order);
console.log(json);

// replacer:函数形式可过滤或改写字段
const masked = JSON.stringify(order, (key, value) => {
  if (key === 'price') return value * 0.9;
  if (key === 'remark') return undefined;
  return value;
});
console.log(masked);

// 第三个参数控制缩进,便于阅读
console.log(JSON.stringify({ a: 1, b: 2 }, null, 2));

// 反序列化:reviver 可以在生成最终对象前处理每个值
const parsed = JSON.parse(json, (key, value) => {
  if (key === 'createdAt') return new Date(value);
  return value;
});
console.log(parsed.createdAt instanceof Date); // true

// 循环引用会抛出 TypeError
const loop = { name: 'loop' };
loop.self = loop;
try {
  JSON.stringify(loop);
} catch (err) {
  console.log('序列化失败:', err.name); // TypeError
}

JSON.parse(JSON.stringify(value)) 是常见的「偷懒深拷贝」,但它会丢失 undefined、函数、Symbol、Date 类型、Map、Set 与 RegExp,遇到循环引用直接报错。只在数据确实由 JSON 安全类型组成时使用。