ADVANCED / 进阶篇

读懂语言的底层:作用域、this 与原型

语法会用只是起点。这一篇把执行上下文、闭包、this、原型链与模块拆开来看, 解释每一行代码在引擎里究竟发生了什么。读完之后,面对“为什么输出是这个”, 你不再只靠记忆,而是能从模型推导出来。

4 个章节 17 个知识点 4 个交互演示 约 100 分钟
Chapter 01

执行上下文与作用域

变量从哪里来、函数如何被调用、闭包为什么能记住状态——这些问题都指向同一套执行模型。

1.1

执行上下文与调用栈

进阶

执行上下文(Execution Context)是 JavaScript 引擎执行代码时创建的环境。开始执行代码时总会进入一个上下文:全局代码对应全局上下文,每次函数调用创建函数上下文,模块代码有模块上下文。每个上下文里保存着变量环境(var 与 function 声明)、词法环境(let、const、class)、this 绑定,以及指向外层环境的引用 outer。

上下文的生命周期分两步。创建阶段先做声明实例化:函数声明整体放入环境,var 声明初始化为 undefined,并确定 this;执行阶段才逐行求值、调用函数。所谓“提升”和“暂时性死区”,差异就来自这两个阶段。函数调用时新上下文被压入调用栈,返回时弹出,栈严格遵循后进先出。

调用栈也能解释报错。无限递归让栈不断增长,最终抛出 RangeError: Maximum call stack size exceeded;调试器里的调用栈面板,就是这条链的可视化。

函数返回顺序与栈的变化

function third() {
  console.log('third:调用栈最深');
}

function second() {
  third();
  console.log('second:third 返回后继续');
}

function first() {
  second();
  console.log('first:second 返回后继续');
}

first();
console.log('global:全部返回后继续');

// 调用栈变化:
// [global]
// [global, first]
// [global, first, second]
// [global, first, second, third]
// 每次函数返回,栈顶的上下文被弹出

// 如果递归没有终止条件,栈会不断增长,最终抛出:
// RangeError: Maximum call stack size exceeded

作用域是静态的,上下文是动态的。作用域在代码书写时就由位置决定,函数定义后不再改变;执行上下文则在每次调用时新建,返回后销毁。不要把两者混为一谈。

1.2

词法作用域与作用域链

进阶

词法作用域(lexical scope)也叫静态作用域,由代码的书写位置决定。函数在定义时就记住了外层环境,至于它在哪里被调用,不影响变量的查找结果。把由内向外的一串环境记录连起来,就是作用域链:当前函数环境 → 外层函数环境 → … → 全局环境。

查找变量时,引擎先看当前环境,没有就沿 outer 逐层向上;一旦找到就停止,同名的外层变量被遮蔽(shadowing)。如果一直找到全局仍不存在,读取会抛 ReferenceError,非严格模式下赋值则会隐式创建全局变量。内层可以访问外层,外层不能反向访问内层。

作用域链不只服务于变量查找,也决定了闭包能访问什么。函数对象创建时保存了指向定义时外层环境的内部引用,所以即使调用发生在别处,查找仍按定义位置进行。

调用位置不改变查找方向

const value = 'global';

function show() {
  console.log(value); // 沿作用域链找到全局的 value
}

function wrapper() {
  const value = 'wrapper';
  show(); // 调用发生在 wrapper 内,但 show 定义在全局
}

wrapper(); // 输出 global,而不是 wrapper

function outer() {
  const name = 'outer';

  function inner() {
    console.log(name); // 自身没有 name,向上找到 outer
  }

  inner();
}

outer(); // outer

const scope = 'global-scope';

function shadow() {
  const scope = 'local-scope'; // 遮蔽外层的 scope
  console.log(scope); // local-scope
}

shadow();
console.log(scope); // global-scope

JavaScript 采用词法作用域,而不是动态作用域。call 与 apply 改变的是 this 和本次执行上下文,不会改写变量的作用域链;with 和 eval 能在运行时干扰作用域,因此严格模式直接禁用了 with。

1.3

变量提升与暂时性死区

进阶

声明提升(hoisting)来自上下文创建阶段的声明扫描。var 声明被提升到所在函数或全局环境的顶部,并初始化为 undefined;function 声明整体提升,名字和函数体都可以提前使用。let、const、class 同样会被创建,但保持未初始化状态。

从进入作用域到声明语句执行之间,这段区域叫暂时性死区(Temporal Dead Zone,简称 TDZ)。在 TDZ 内访问变量会抛 ReferenceError,typeof 也不能幸免。函数表达式按 var 或 let 的规则处理,不会像函数声明那样整体提升。

实践上不必背诵细节:把声明写在作用域顶部、先声明后使用,就能避开绝大多数陷阱。需要预测输出时,再回到“创建阶段做什么、执行阶段做什么”这两步推导。

先猜输出,再看注释

console.log(a); // undefined:var 声明提升,赋值没有
// console.log(b); // ReferenceError:b 处于暂时性死区
var a = 1;
let b = 2;
const c = 3;

sayHi(); // 正常执行:函数声明整体提升
function sayHi() {
  console.log('hi');
}

// greet(); // TypeError:greet 此时是 undefined,不是函数
var greet = function () {
  console.log('hello');
};

{
  // console.log(temp); // ReferenceError:进入块级作用域即进入 TDZ
  let temp = 'block';
  console.log(temp); // block
}

// typeof 也不能绕过 TDZ
// console.log(typeof later); // ReferenceError
let later = 10;

// 函数表达式不会整体提升
// console.log(typeof sum); // "undefined"
var sum = (x, y) => x + y;
console.log(sum(2, 3)); // 5
维度 var let const
作用域 函数或全局 块级 块级
提升行为 提升并初始化为 undefined 提升但处于 TDZ 提升但处于 TDZ
重复声明 允许 同一作用域报错 同一作用域报错
重新赋值 允许 允许 不允许,对象内容仍可修改
全局脚本中挂到 window 是 否 否
初始化 可以省略 可以省略 必须立即初始化

TDZ 是“时间”概念,不是“位置”概念。只要还没执行到声明语句,访问就会报错,哪怕声明写在同一个块里、看起来离得很近。

1.4

闭包:让状态活下来

重点

闭包(closure)是函数与其词法环境的组合。更具体地说,内层函数在定义时保存了对外层环境的引用;即使外层函数已经返回,这些变量仍然存活,内层函数依然可以读写它们。闭包不是语法特性,而是作用域链带来的自然结果。

形成闭包通常需要三个条件:存在函数嵌套;内层函数引用了外层函数的变量;内层函数在外层函数之外被调用,例如被返回、作为回调、挂到对象上。只满足前两条而不逃逸出外层,通常不值得单独讨论。

常见用途包括保存状态(计数器、缓存)、模拟私有变量、函数工厂、模块模式,以及防抖节流。要记住:闭包保存的是变量本身,不是创建时的值快照;多个函数可以共享同一份状态,也会一起看到后续的修改。

计数器与私有变量

function makeCounter(start = 0, step = 1) {
  let count = start; // 被闭包保存的状态

  return {
    inc() {
      count += step;
      return count;
    },
    value() {
      return count;
    }
  };
}

const counterA = makeCounter();
const counterB = makeCounter(10, 5);

console.log(counterA.inc()); // 1
console.log(counterA.inc()); // 2
console.log(counterB.inc()); // 15
console.log(counterA.value()); // 2
// 两次 makeCounter 调用产生两个独立环境,
// 因此 counterA 与 counterB 的状态互不影响

function createAccount(initial) {
  let balance = initial;
  return {
    deposit(amount) {
      if (amount > 0) balance += amount;
      return balance;
    },
    get balance() {
      return balance; // 只读出口,外部无法直接改写 balance
    }
  };
}

const account = createAccount(100);
account.deposit(50);
console.log(account.balance); // 150
交互演示 / 闭包与私有状态两个计数器互不影响

下面两个计数器由同一个 makeCounter 创建,但各自持有一份独立的 count。分别点几次,观察它们的状态。

闭包捕获的是变量的绑定,而不是值。如果外层变量之后被修改,闭包读取到的是修改后的值;这也解释了循环中共享变量带来的陷阱。

1.5

闭包的经典陷阱与内存代价

重点

最经典的陷阱是 var 配合异步回调。var 声明的循环变量属于函数或全局作用域,三轮循环共用同一个 i;setTimeout 的回调要等循环结束后才执行,那时 i 已经是终止值,于是三个回调打印出相同的结果。

修复有两条路。立即执行函数(IIFE)在每一轮创建一个新的函数作用域,把当前值作为参数复制进去;let 则更直接,for 循环会为每次迭代创建新的绑定,回调各自捕获当轮的值。现代代码优先使用 let。

闭包还有内存代价:被闭包引用的变量不会被垃圾回收。长时间存活的定时器、事件监听器如果捕获了大数组或 DOM 节点,内存占用会持续升高。用完后应解除引用、移除监听器或清空缓存,不要为了“封装”而无谓地捕获大对象。

循环陷阱的两种修复

// 陷阱:var 只有函数作用域,三轮共用同一个 i
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log('var:', i), 0);
}
// 输出:var: 3 / var: 3 / var: 3

// 修复一:IIFE 把当轮的值复制成参数 n
for (var j = 0; j < 3; j++) {
  (function (n) {
    setTimeout(() => console.log('IIFE:', n), 0);
  })(j);
}
// 输出:IIFE: 0 / IIFE: 1 / IIFE: 2

// 修复二:let 为每次迭代创建新绑定
for (let k = 0; k < 3; k++) {
  setTimeout(() => console.log('let:', k), 0);
}
// 输出:let: 0 / let: 1 / let: 2

// 闭包持有大对象时,内存不会随外层函数结束而释放
function createReader() {
  const data = new Array(1e6).fill('x'); // 约 8MB 的数组
  return function () {
    return data.length; // data 被闭包引用,无法回收
  };
}

let reader = createReader();
console.log(reader()); // 1000000
reader = null; // 解除引用后,垃圾回收器才有机会回收 data

事件监听器、定时器、全局缓存都是闭包的常见宿主。移除监听时不要只写空函数,要传入当初注册的同一个函数引用;否则闭包与它捕获的对象会一直留在内存里。

Chapter 02

this 与调用方式

this 不是“函数自己的引用”,而是本次调用留下的线索。理解它,关键在看调用表达式,而不是看函数体。

2.1

this 的五种绑定规则

进阶

this 是函数被调用时确定的执行上下文信息,而不是函数定义时决定的(箭头函数是例外)。同一个函数换一种调用方式,this 就可能完全不同。判断 this 时,先找到调用表达式,再套用绑定规则。

规则一共五条。默认绑定:独立调用,非严格模式指向全局对象,严格模式是 undefined。隐式绑定:作为对象方法调用,指向调用它的对象。显式绑定:用 call、apply、bind 指定。new 绑定:指向新创建的实例。箭头函数没有自己的 this,沿用定义处外层的 this。

优先级是 new > 显式 > 隐式 > 默认。最常见的坑是“方法被单独取出”后丢失隐式绑定:赋值给变量或作为回调传入,调用形式退化为独立调用,this 也就变成了默认绑定。

同一函数,不同调用

function whoAmI() {
  console.log(this && this.label);
}

const person = {
  label: 'person',
  whoAmI
};

whoAmI();        // 默认绑定:非严格模式是 window,严格模式是 undefined
person.whoAmI(); // 隐式绑定:person

const detached = person.whoAmI;
detached();      // 丢失绑定:又退化为默认绑定

whoAmI.call({ label: 'call' });   // 显式绑定
whoAmI.apply({ label: 'apply' }); // 显式绑定
const bound = whoAmI.bind({ label: 'bind' });
bound();                          // 显式绑定,之后无法再改

function Person(label) {
  this.label = label;
}
const p = new Person('new');
console.log(p.label); // new

const arrow = () => this; // 定义在全局,捕获全局 this
console.log(arrow() === globalThis); // 浏览器经典脚本中为 true

// 优先级:new > 显式 > 隐式 > 默认
function Tag() {}
const holder = { tag: Tag };
const instance = new holder.tag(); // new 优先
console.log(instance instanceof Tag); // true
绑定方式 调用形式 this 指向
默认绑定 fn() 非严格模式的全局对象,严格模式为 undefined
隐式绑定 obj.fn() 调用它的对象 obj
显式绑定 fn.call(obj)、apply、bind 显式指定的 obj
new 绑定 new Fn() 新创建的实例
箭头函数 定义时捕获 外层词法 this,无法被 call 改变
交互演示 / this 绑定实验点击切换调用方式

同一个函数用不同方式调用,this 的指向会随之变化。逐个点击,对比输出结果。

点击任意按钮,查看这一次调用中的 this。

把对象方法当作回调传递时,隐式绑定会丢失。常见的修复是 fn.bind(obj),或者在定义时用箭头函数包一层;直接写 obj.method 往往不是你以为的那个调用。

2.2

手写 call、apply 与 bind

重点

call 和 apply 都会立即调用函数并指定 this,区别只在参数形式:call 逐个传参,apply 接收数组或类数组。bind 不立即调用,而是返回一个新函数,把 this 永久固定,并允许预置部分参数,也就是柯里化。

手写 call 的关键:把函数临时挂到目标对象上,用“对象方法调用”的方式触发隐式绑定;用 Symbol 作为临时键,避免覆盖对象已有属性;调用后删除临时属性,并返回原函数的结果。目标为 null 或 undefined 时,非严格模式要回退到全局对象。

手写 bind 还要多考虑一层:返回的函数被 new 调用时,绑定的 this 应被忽略,新实例才是 this,同时原型链要保持可用。原生 bind 生成的函数不能再次改变 this,也没有自己的 prototype。

最小可用实现

Function.prototype.myCall = function (context, ...args) {
  if (typeof this !== 'function') {
    throw new TypeError('myCall 只能由函数调用');
  }
  // null / undefined 在非严格模式下回退到全局对象
  context = context == null ? globalThis : Object(context);
  const key = Symbol('fn'); // 避免覆盖对象已有属性
  context[key] = this;
  const result = context[key](...args);
  delete context[key];
  return result;
};

Function.prototype.myApply = function (context, args = []) {
  return this.myCall(context, ...args);
};

Function.prototype.myBind = function (context, ...preset) {
  const fn = this;
  function bound(...later) {
    // 用 new 调用时,this 是新实例,应忽略绑定的 context
    const isNew = this instanceof bound;
    return fn.myCall(isNew ? this : context, ...preset, ...later);
  }
  // 保留原型,使 new bound() 的实例仍能访问原型的属性
  bound.prototype = Object.create(fn.prototype);
  return bound;
};

function intro(city) {
  return `${this.name} · ${city}`;
}
const person = { name: '林间' };
console.log(intro.myCall(person, '杭州'));    // 林间 · 杭州
console.log(intro.myApply(person, ['杭州'])); // 林间 · 杭州
const boundIntro = intro.myBind(person, '杭州');
console.log(boundIntro());                    // 林间 · 杭州

手写实现只用于理解机制。真实项目中直接用原生的 call、apply、bind:它们处理了边界情况,性能也更好。箭头函数没有自己的 this,任何绑定方法都无法改变它。

2.3

箭头函数的 this 与适用场景

进阶

箭头函数没有 [[Construct]],没有自己的 prototype,也没有 this、arguments、super 和 new.target。函数体里的 this 在定义时从外层词法环境捕获,之后不会改变;call、apply、bind 传入的 this 会被直接忽略。

因此它适合写回调:数组方法、Promise 链、定时器,以及事件处理器中需要沿用外层 this 的场景。它也很适合短小的纯函数,能让代码更紧凑。

它不适合作为对象字面量的方法,因为 this 不会指向这个对象;不适合需要动态 this 的方法、需要 arguments 的函数,也不能用作构造函数。类的方法同样不要随手改成箭头函数。

继承外层 this,而不是拥有自己的 this

const timer = {
  seconds: 0,
  start() {
    // 普通函数作为回调,this 不再指向 timer
    // setInterval(function () { this.seconds++; }, 1000);

    this.id = setInterval(() => {
      this.seconds += 1; // 箭头函数沿用 start 的 this
      if (this.seconds >= 3) {
        clearInterval(this.id);
        console.log('计时结束', this.seconds);
      }
    }, 1000);
  }
};
timer.start();

const arrow = () => this;
const fake = { label: 'fake' };
console.log(arrow.call(fake) === globalThis); // 浏览器经典脚本中为 true

function Person(name) {
  this.name = name;
  // 箭头函数作为实例方法,this 在构造时被固定
  this.say = () => this.name;
}

const p = new Person('阿禾');
const say = p.say;
console.log(say()); // 阿禾,脱离对象调用也不会丢 this

// 反例:对象方法不要用箭头函数
const bad = {
  name: 'bad',
  greet: () => this.name // this 是外层,浏览器经典脚本中为 window
};
console.log(bad.greet()); // undefined

需要访问 arguments 时,用剩余参数 ...args 代替。需要动态 this 时,用普通函数或方法简写。选择哪一种,先问“这个 this 应该由谁决定”,答案就清楚了。

Chapter 03

对象、原型与继承

对象是属性的集合,原型是查找的下一站。把 prototype、__proto__、constructor 与 class 放回同一条链上,继承就不再神秘。

3.1

prototype、__proto__ 与 constructor

进阶

每个普通函数在创建时都会获得一个 prototype 属性,指向一个对象,这个对象就是将来实例的原型。用 new 调用构造函数时,引擎先创建一个新对象,把它的内部 [[Prototype]] 设置为构造函数的 prototype,再以新对象为 this 执行构造函数。

实例的 __proto__ 指向构造函数的 prototype,而 prototype 上的 constructor 又指回构造函数本身。三者构成一个闭环,但方向不同:prototype 是函数到原型对象,[[Prototype]] 是实例到原型对象,constructor 是原型对象回到构造函数。注意 __proto__ 只是历史遗留的访问器,规范推荐 Object.getPrototypeOf。

把方法放在 prototype 上,所有实例共享同一份函数,节省内存;把状态放在构造函数里,每个实例才有独立的一份。实例自身属性会遮蔽原型上的同名属性,这也是查找链的第一站。

一条闭环,三个方向

function Book(title) {
  this.title = title; // 实例自身属性,每个实例独立
}

Book.prototype.describe = function () {
  return `《${this.title}》`;
};
Book.prototype.category = '技术';

const js = new Book('JavaScript 高级程序设计');
const css = new Book('CSS 世界');

console.log(js.describe()); // 《JavaScript 高级程序设计》

// 实例的 [[Prototype]] 指向构造函数的 prototype
console.log(Object.getPrototypeOf(js) === Book.prototype); // true
console.log(js.__proto__ === Book.prototype); // true,仅用于理解
console.log(Book.prototype.constructor === Book); // true

// 原型上的属性由所有实例共享
console.log(js.category, css.category); // 技术 技术

// 实例自身属性会遮蔽原型上的同名属性
js.category = '前端';
console.log(js.category); // 前端
console.log(css.category); // 技术
console.log(Object.hasOwn(js, 'category')); // true

箭头函数没有 prototype,因此不能作为构造函数;class 的原型方法不可枚举,普通函数的原型方法默认可枚举。遍历对象时,这些差异会造成实际影响。

3.2

原型链查找与 instanceof

重点

读取属性时,引擎先检查对象自身是否有该属性;没有就沿 [[Prototype]] 指向的对象继续查找,一层层向上,直到 null 为止。找到就返回,找不到返回 undefined,而不是报错。写入属性时通常只修改对象自身,不会顺着原型链改到上层。

原型链的终点是 Object.prototype,它的 [[Prototype]] 是 null。instanceof 的判断逻辑很直接:检查右操作数的 prototype 是否出现在左操作数对象的原型链上。因此 dog instanceof Dog 与 dog instanceof Animal 可以同时为真。

这带来性能含义:查找层级越深、属性越靠上,成本越高;在热路径里频繁访问深层属性会拖慢代码。另外,for...in 会枚举继承来的可枚举属性,Object.keys 只返回自身可枚举属性,二者不能混用。

逐层向上的查找过程

const base = { kind: 'base' };
const middle = Object.create(base);
middle.name = 'middle';
const leaf = Object.create(middle);
leaf.id = 1;

console.log(leaf.id);      // 1,自身属性
console.log(leaf.name);    // middle,第一层原型
console.log(leaf.kind);    // base,第二层原型
console.log(leaf.missing); // undefined,走到 null 仍未找到

// 原型链的终点
console.log(Object.getPrototypeOf(base) === Object.prototype); // true
console.log(Object.getPrototypeOf(Object.prototype)); // null

// in 检查整条原型链,hasOwn 只检查自身
console.log('name' in leaf); // true
console.log(Object.hasOwn(leaf, 'name')); // false

// instanceof:构造函数的 prototype 是否在原型链上
function Animal() {}
function Dog() {}
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

const dog = new Dog();
console.log(dog instanceof Dog);    // true
console.log(dog instanceof Animal); // true
console.log(dog instanceof Object); // true
console.log(dog instanceof Array);  // false
交互演示 / 原型链查找逐层向上,直到 null

对象链为 leaf → middle → base → Object.prototype → null。选择属性,观察引擎从哪一层命中。

for...in 会连原型上的可枚举属性一起遍历,常让计数结果偏大。需要自身属性时,用 Object.keys 或 Object.hasOwn 过滤。

3.3

创建对象的多种方式

进阶

字面量最直接,适合配置、单例和简单的数据结构,缺点是无法批量创建同构对象。工厂函数把创建逻辑封装起来,返回对象即可,不依赖 new,也不会出现忘记 new 的问题,但无法通过 instanceof 识别类型。

构造函数配合 new 可以批量创建实例,方法放在 prototype 上共享。忘记写 new 时,非严格模式下 this 会指向全局对象,造成污染;严格模式则直接报错。这正是类名首字母大写、调用时保持警惕的原因。

Object.create(null) 创建没有原型的对象,适合做字典或缓存,避免键名与 toString、constructor 等原型属性冲突。class 是构造函数的语法糖,提供更清晰的语义、继承与私有字段。

五种常见写法

// 1. 字面量:简单直接
const config = { theme: 'sage', lang: 'zh-CN' };

// 2. 工厂函数:封装创建过程,不需要 new
function createUser(name, role = 'reader') {
  return {
    name,
    role,
    greet() {
      return `${name} 你好`;
    }
  };
}
const user = createUser('阿禾');

// 3. 构造函数:方法放在原型上共享
function Point(x, y) {
  this.x = x;
  this.y = y;
}
Point.prototype.length = function () { return Math.hypot(this.x, this.y); };
const p = new Point(3, 4);

// 4. 无原型对象:适合做字典
const dict = Object.create(null);
dict.key = 'value';
console.log('toString' in dict); // false,不继承 Object.prototype
console.log(dict.key); // value

// 5. class:语义更清晰
class Rectangle {
  constructor(width, height) { this.width = width; this.height = height; }
  area() {
    return this.width * this.height;
  }
}

console.log(user.greet());             // 阿禾 你好
console.log(p.length());               // 5
console.log(new Rectangle(2, 3).area()); // 6

Object.create(null) 创建的对象没有 hasOwnProperty 等方法,需要借用 Object.prototype.hasOwnProperty.call(dict, key),或者直接用 Object.hasOwn(dict, key)。

3.4

class 语法:字段、访问器与私有成员

重点

class 是构造函数的语法糖,但行为更严格:类声明不提升,处于 TDZ;类体默认运行在严格模式;原型方法不可枚举;必须用 new 调用,直接调用类会抛 TypeError。

constructor 负责初始化实例;写在类体里的普通方法进入 prototype;get 与 set 定义访问器;static 方法或字段属于类本身,通过类名调用;实例字段在构造时初始化。私有字段以 # 开头,只能在类体内部访问。

私有字段提供的是语言层面的封装,不是安全边界。它能防止外部误用、避免命名冲突,但无法阻止调试工具查看内存。真正的敏感数据不应只依赖 # 保护。

温度换算类

class Temperature {
  #celsius = 0;      // 私有字段,只能在类体内部访问
  unit = 'C';        // 实例字段,每个实例独立

  constructor(celsius = 0) {
    this.#celsius = celsius;
  }

  get celsius() {
    return this.#celsius;
  }

  set celsius(value) {
    if (typeof value !== 'number' || Number.isNaN(value)) {
      throw new TypeError('温度必须是数字');
    }
    this.#celsius = value;
  }

  get fahrenheit() {
    return this.#celsius * 9 / 5 + 32;
  }

  static fromFahrenheit(f) {
    return new Temperature((f - 32) * 5 / 9);
  }

  toString() {
    return `${this.#celsius}°C`;
  }
}

const t = Temperature.fromFahrenheit(212);
console.log(t.celsius);    // 100
console.log(t.fahrenheit); // 212
t.celsius = 0;
console.log(String(t));    // 0°C
// console.log(t.#celsius); // SyntaxError:私有字段不能在类外访问

类字段在每次实例化时按顺序初始化,箭头函数也可以作为字段,从而把 this 固定到实例上。这与在构造函数里写 this.fn = () => {} 的效果一致。

3.5

继承:extends 与 super

深入

extends 建立两条链:子类 prototype 的原型指向父类 prototype,实例方法因此可以继承;子类构造函数自身的原型指向父类构造函数,静态成员也因此可以继承。super 有两种用法:super(...) 调用父类构造函数,super.method(...) 调用父类原型上的方法。

子类构造函数里必须先调用 super() 才能使用 this;如果子类没有写 constructor,会自动补上 constructor(...args) { super(...args); }。方法重写时,子类同名方法会覆盖父类,必要时用 super 复用父类逻辑。

继承适合表达 is-a 关系。层级过深会让修改牵一发动全身,也容易在构造函数里漏掉 super。优先用组合:把能力拆成独立对象,再按需混入,而不是为了复用几行代码强行继承。

重写、静态继承与组合

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    return `${this.name} 发出声音`;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // 必须先调用,之后才能使用 this
    this.breed = breed;
  }
  speak() {
    return `${super.speak()}:汪汪`;
  }
}

const dog = new Dog('豆豆', '柴犬');
console.log(dog.speak()); // 豆豆 发出声音:汪汪
console.log(dog instanceof Dog);    // true
console.log(dog instanceof Animal); // true

// 静态成员也会被继承
class Base {
  static version = '1.0';
}
class Sub extends Base {}
console.log(Sub.version); // 1.0

// 组合:把可复用的能力做成独立对象
const canFly = {
  fly() {
    return `${this.name} 起飞`;
  }
};
class Bird extends Animal {}
Object.assign(Bird.prototype, canFly);
console.log(new Bird('青鸟').fly()); // 青鸟 起飞
交互演示 / class 继承与 super观察输出

Dog 继承 Animal 并重写 speak,Bird 通过混入获得 fly。点击按钮查看实际结果。

不要在 super() 之前访问 this,也不要在 super() 之前把 this 交给箭头函数或回调;这些写法都会抛 ReferenceError,因为实例尚未初始化。

Chapter 04

现代语法与模块化

解构让取值更直接,模板字符串让拼接更清楚,模块让依赖有边界,严格模式让错误更早暴露。

4.1

解构赋值与展开、剩余

基础

解构是按模式从数组或对象中取值。数组按位置匹配,对象按属性名匹配;支持默认值、重命名、嵌套和剩余。默认值只在取到的值为 undefined 时生效,null 不会触发默认值,这一点常被忽略。

函数参数可以直接解构,并给整个参数对象一个 {} 默认值,避免调用时不传参就报错。这种写法适合配置对象:调用方只传需要的字段,函数内部拿到补齐默认值后的结构。

展开运算符用于浅拷贝与合并,它只复制第一层;嵌套对象或数组仍然共享引用。剩余元素则把未匹配的部分收集成新的数组或对象。需要深拷贝时,必须显式递归或使用结构化克隆,不能指望展开。

从取值到浅拷贝

const [first, , third = '默认值'] = ['a', 'b'];
console.log(first, third); // a 默认值

const user = {
  name: '阿禾',
  age: 24,
  address: { city: '杭州' }
};

const { name: userName, age = 18, ...rest } = user;
console.log(userName); // 阿禾
console.log(age);      // 24
console.log(rest);     // { address: { city: '杭州' } }

function draw({ color = 'sage', size = 12 } = {}) {
  return `${color} / ${size}`;
}
console.log(draw());             // sage / 12
console.log(draw({ size: 20 })); // sage / 20

// 展开是浅拷贝:嵌套引用仍然共享
const copy = { ...user, age: 25 };
copy.address.city = '上海';
console.log(copy.age, user.age); // 25 24
console.log(user.address.city);  // 上海

// 交换变量
let x = 1;
let y = 2;
[x, y] = [y, x];
console.log(x, y); // 2 1

{ ...obj } 与 [...arr] 都只做浅拷贝。嵌套对象被修改时,原对象也会变化;如果数据需要独立,使用 structuredClone 或逐层复制。

4.2

模板字符串与标签模板

进阶

模板字符串用反引号包裹,支持多行文本和 ${} 插值。插值表达式会先求值,再转成字符串;它比用 + 拼接更易读,也不会漏掉空格。多行文本中的缩进与换行会被原样保留。

标签模板是在模板字符串前加一个函数名,写成 tag`...`。标签函数接收两个部分:字符串片段数组,以及所有插值。于是它可以在拼接之前做转义、国际化、语法高亮等处理。strings.raw 还能拿到未经转义处理的原始文本。

要特别注意:标签模板不会自动做 HTML 转义。如果要把用户输入插入页面,仍然需要显式转义,或者优先使用 textContent。下面这个简易转义器展示了标签函数的典型用法。

手写一个 HTML 转义标签

const name = '阿禾';
const message = `你好,${name}
这是第二行,缩进和换行都会保留`;
console.log(message);

const price = 19.9;
console.log(`总价:${(price * 2).toFixed(2)} 元`); // 总价:39.80 元

// 标签函数:strings 是字符串片段,values 是插值
function escapeHTML(strings, ...values) {
  const map = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#39;'
  };
  return strings.reduce((out, str, i) => {
    const value = values[i - 1];
    const safe = value === undefined
      ? ''
      : String(value).replace(/[&<>"']/g, ch => map[ch]);
    return out + safe + str;
  });
}

const input = '<img src=x onerror=alert(1)>';
const html = escapeHTML`<p>${input}</p>`;
console.log(html);
// &lt;p&gt;&lt;img src=x onerror=alert(1)&gt;&lt;/p&gt;

标签函数可以返回任意类型的值,不一定是字符串。借助这一点,可以实现带参数的查询构造器、CSS 辅助函数或国际化词典,而不只是做字符串拼接。

4.3

ES Module:import 与 export

重点

ES Module 使用 import 与 export 声明依赖,依赖关系在编译阶段静态确定,因此可以做静态分析、tree shaking 与循环依赖检测。一个模块可以同时有默认导出和多个命名导出;导入时可用 as 重命名,也可以用 import * as ns 收集为命名空间对象。

模块拥有独立的顶层作用域,不会污染全局;模块默认运行在严格模式;模块顶层的 this 是 undefined。同一个模块无论被导入多少次,都只执行一次,所有导入方共享同一份实例,这一点适合放全局配置或单例。

动态 import() 返回 Promise,适合按需加载与代码分割。它与 CommonJS 的差异也很关键:ESM 是静态声明、导出的是实时绑定(live binding);CommonJS 在运行时 require,导出的是值的拷贝。此外 ESM 支持顶层 await。

两个文件之间的导入与导出

// ---------- utils.js ----------
export const PI = 3.14159;

export function area(radius) {
  return PI * radius ** 2;
}

export default class Circle {
  constructor(radius) {
    this.radius = radius;
  }
  area() {
    return area(this.radius);
  }
}

// ---------- main.js ----------
import Circle, { PI, area as circleArea } from './utils.js';
import * as utils from './utils.js';

console.log(PI, utils.PI);         // 3.14159 3.14159
console.log(circleArea(2));        // 12.56636
console.log(new Circle(1).area()); // 3.14159
console.log(this);                 // undefined,模块顶层 this

// 动态导入:返回 Promise,适合按需加载
async function loadChart() {
  const { Chart } = await import('./chart.js');
  return new Chart();
}

loadChart().catch(error => {
  console.error('模块加载失败', error);
});

浏览器中需要在 script 标签上写 type="module",并通过 HTTP 服务访问页面。直接双击打开 file:// 时,模块请求会被 CORS 策略拦截,控制台通常会提示跨源错误。

4.4

严格模式与常见怪异行为

进阶

'use strict' 用于开启严格模式,可以写在脚本顶部(整段脚本生效),也可以写在函数体顶部(该函数生效)。ES Module 与 class 内部自动是严格模式,不需要手动声明。

严格模式带来的变化很具体:未声明就赋值会抛 ReferenceError,而不是创建全局变量;普通函数调用的 this 是 undefined,而不是全局对象;禁止 with;禁止旧式八进制字面量 0755,应改用 0o755;禁止删除变量;函数参数不能重名;arguments 不再与形参联动;eval 不会在外部作用域引入变量。

这些限制让错误更早暴露,也避免了一些引擎优化障碍。新代码应默认使用严格模式,模块和类已经自动满足;维护旧代码时,再逐步迁移,而不是一次性全局开启。

严格模式下的几个直接变化

'use strict';

// 1. 未声明变量直接赋值会报错
try {
  leaked = 'oops';
} catch (error) {
  console.log(error.name); // ReferenceError
}

// 2. 普通函数调用时 this 是 undefined
function whoAmI() {
  return this;
}
console.log(whoAmI()); // undefined

// 3. 禁止 with(语法错误,不能放在 try 里)
// with (Math) { console.log(PI); }

// 4. 禁止旧式八进制字面量
// const mode = 0755; // SyntaxError
const mode = 0o755;   // 正确写法
console.log(mode);    // 493

// 5. 参数不能重名
// function sum(a, a) { return a; } // SyntaxError

// 6. arguments 与形参解耦
function demo(value) {
  arguments[0] = 99;
  console.log(value); // 1,严格模式下不再联动
}
demo(1);

// 7. 删除变量是语法错误
// const obj = { a: 1 };
// delete obj;

严格模式不是“更安全的运行环境”,而是“更早暴露错误的语法模式”。它不会替你处理类型问题,也不会阻止逻辑错误,但能消除一批历史遗留的隐式行为。