类不是魔法:class 与原型链实战指南
菜单上的每道菜是一个实例,订单分普通和外卖,会员分普通和 VIP,继承关系就长在这些类上。本文按 MDN 的《使用类》与《继承与原型链》两份指南讲清楚:构造器、方法与原型、私有字段、访问器、静态、继承、原型链查找与猴子补丁红线。

先把这篇的边界说清楚。站里已经有《解构赋值实战指南》,讲的是把对象和数组一次拆成几个变量;还有《数组方法实战指南》,讲的是手里有一列东西怎么加工;还有《闭包与作用域实战指南》,讲的是变量谁能看见。这篇不讲拆包、不讲加工列表、不讲变量,只讲一件事:class 是什么、方法到底存在哪、找不到的属性会顺着哪条链去找。类用对了,一类东西的数据和行为能收在一个地方;用错了,继承的链一绕,改一处全站都变。下面用到的“青石咖啡馆”还是那个虚构的练手项目:一个帮街边咖啡馆做点单的网页小工具。这回讲的是它的菜单、订单和会员:菜单上的每道菜是一个实例,订单分普通订单和外卖订单,会员分普通会员和 VIP 会员,继承关系就长在这些类上。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于类与原型链的语法和行为,都来自 MDN 的《Using classes(使用类)》指南和《Inheritance and the prototype chain(继承与原型链)》指南,来源见每篇的 meta 信息与 evidence 记录。MDN 文档里的例子,比如 Date 日期、Color 颜色、Box 盒子、Graph 图,都是文档自带的示例,不是真实用户数据。
第一步:类有三个特征,Date 就是现成的例子
不用自己写类,也能先看懂类是什么:JavaScript 内置的 Date 就是一个类。MDN 的例子是:const bigDay = new Date(2019, 6, 19),bigDay.toLocaleDateString() 返回一个字符串,bigDay.getTime() 返回一个数字,Date.now() 直接从类本身调用。从这个例子能看出类的三个特征:第一,类通过 new 运算符创建对象;第二,每个对象都带上类给它的一些属性,数据或者方法;第三,类自己身上也存了一些属性,通常用来跟实例打交道。这三个特征对应类的三个关键部分:构造器、实例方法与实例字段、静态方法与静态字段。咖啡馆的菜单就是这么建模的:每道菜是一个 Dish 实例,new Dish("拿铁", 28) 造出一道菜,dish.price 是它的数据,dish.format() 是它的方法,Dish.isValidPrice(28) 是类自己的方法。记住第一句话:new 造实例,实例带数据和方法,类自己也带一份。
第二步:类声明长这样,不提升、不用 new 会报错
类通常用类声明来创建。MDN 的例子是:class MyClass { constructor() {} myField = "foo"; myMethod() {} static myStaticField = "bar"; static myStaticMethod() {} static {} #myPrivateField = "bar"; }。一个类体里能放的东西就这几样:构造器、实例字段、实例方法、静态字段、静态方法、静态块,以及它们的私有形式。声明之后,用 new 创建实例:const myInstance = new MyClass(),myInstance.myField 是 'foo',myInstance.myMethod() 能直接调用。两条红线要记牢:第一,普通函数构造器既能 new 也能直接调用,类不行,不用 new 调用类会报错,TypeError:Class constructor MyClass cannot be invoked without 'new';第二,类声明不像函数声明那样会被提升,声明之前用类会报错,ReferenceError:Cannot access 'MyClass' before initialization,行为和 let、const 声明的变量一样。类也有表达式形式:const MyClass = class { },具名表达式的名字只在类体里可见,类体外面用那个名字会报 ReferenceError。咖啡馆的订单类就踩过这个坑:文件顶部先 new Order()、类声明写在文件底部,页面一加载就报类还没初始化。记住判断句:类先声明、后使用;造实例一定写 new。
第三步:构造器是造实例的工厂,this 就是新实例
类最重要的工作,是当对象的“工厂”,造实例的活由构造器来干。MDN 的例子是 Color 类:class Color { constructor(r, g, b) { this.values = [r, g, b]; } },const red = new Color(255, 0, 0),red.values 是 [255, 0, 0]。构造器的语法和普通函数一模一样,所以 rest 参数也能用:constructor(...values) { this.values = values; }。每次调用 new,造出来的都是不同的实例:const red = new Color(255, 0, 0),const anotherRed = new Color(255, 0, 0),red === anotherRed 是 false。构造器里 this 指向刚创建的新实例,new 的结果会自动返回这个 this。MDN 提醒:不要从构造器里返回东西,因为返回一个非原始值会取代 this,成为 new 表达式的结果。MDN 的例子是:构造器里写了 return {},new MyClass().myField 就是 undefined,因为 this 被丢掉了。咖啡馆的菜品类就是这么写的:class Dish { constructor(name, price) { this.name = name; this.price = price; } },每次 new Dish 都是一道新菜,哪怕名字和价格一模一样,两个实例也不相等。记住判断句:构造器只管往 this 上挂数据,别返回值;每次 new 都是新实例。
第四步:方法存在原型上,所有实例共用一份
只有构造器的类,和一个造普通对象的工厂函数没多大区别,类的本事在于:方法会自动挂到实例身上。MDN 的 Color 例子加了一个 getRed 方法:class Color { constructor(r, g, b) { this.values = [r, g, b]; } getRed() { return this.values[0]; } },const red = new Color(255, 0, 0),red.getRed() 是 255。还可以把方法写在构造器里:this.getRed = function () { return this.values[0]; },这样也能跑,但问题是每次创建实例都会新建一个函数,哪怕它们做的事一模一样。MDN 的验证是:new Color().getRed === new Color().getRed 是 false。用方法写法就不会这样:方法存在所有实例的原型上,也就是 Color.prototype,实例之间共用同一个函数,this 不同,行为就不同。MDN 还补了一个 setRed:red.setRed(0) 之后,red.getRed() 是 0。咖啡馆的菜单卡片就踩过这个坑:渲染函数写在构造器里,一百道菜就有一百份一模一样的函数,内存白白多了一截,改成方法写法,一百个实例共用一份。记住判断句:方法写在类体里,所有实例共用一份;写在构造器里,每个实例一份新的。
第五步:私有字段是真私有,封装靠它兜底
直接访问 values 有什么不好?MDN 举了一个改表示方法的例子:如果哪天颜色不用 RGB 存、改用 HSL 存,red.values[0] 就不再是 255,而是纯红色的色相值 0,用户的代码直接就断了。这就是面向对象里说的“封装”:不要让用户碰对象的内部实现,只给抽象好的方法。类里的做法是私有字段:标识符前面加一个 # 号。MDN 的例子是:class Color { #values; constructor(r, g, b) { this.#values = [r, g, b]; } getRed() { return this.#values[0]; } setRed(value) { this.#values[0] = value; } }。私有字段是“硬私有”:类外访问 red.#values 是早期的语法错误,SyntaxError;没有实现暴露方法,类外没有任何办法拿到它。还可以往 setRed 里加校验:value 小于 0 或者大于 255,抛 RangeError:Invalid R value,red.setRed(1000) 直接报错;values 暴露在外的话,用户改 values[0] 就能绕过这道检查。私有字段还有三条规矩:同一个类里,类方法能读其他同类实例的私有字段,red.redDifference(crimson) 是 35;不知道对方是不是同类实例时,用 #values in anotherColor 先检查;同一个名字不能在类里声明两次,私有字段也不能 delete,都是早期语法错误。咖啡馆的会员余额就是这么管的:balance 是私有字段,只能走 recharge 和 spend 方法,spend 里校验余额不足就报错,外部直接改余额的路被堵死了。记住判断句:内部数据加 #,校验写进方法里,别把裸数据递到用户手上。
第六步:访问器让方法用起来像属性
用 getRed、setRed 读写一个值,总归有点啰嗦,访问器能让方法用起来像真正的属性。MDN 的例子是:class Color { constructor(r, g, b) { this.values = [r, g, b]; } get red() { return this.values[0]; } set red(value) { this.values[0] = value; } },const red = new Color(255, 0, 0),red.red = 0,red.red 是 0。看起来实例上有个叫 red 的属性,其实实例上根本没有这个属性,只有两个分别以 get 和 set 开头的方法,让它用起来像属性。只有 getter、没有 setter 的字段,实际上就是只读的。MDN 的例子是:只有 get red() 的 Color,red.red = 0 之后,red.red 还是 255;严格模式下这一行会直接抛错,TypeError,非严格模式下赋值被静默忽略。咖啡馆的订单总价就是这么写的:order.total 只有一个 getter,内部是 reduce 把菜价加起来算出来的,外部只能读、不能改,想改总价只能改订单里的菜。记住判断句:get 加 set 是可读写属性,只有 get 是只读属性;严格模式下给只读属性赋值会抛错。
第七步:公共字段每个实例一份,静态的挂在类身上
私有字段有公共的对应物:每个实例都能有一份自己的属性。MDN 的例子是:class MyClass { luckyNumber = Math.random(); },new MyClass().luckyNumber 每次都不一样,0.5、0.3 都有可能。公共字段几乎等价于在构造器里给 this 赋值:constructor() { this.luckyNumber = Math.random(); }。字段通常和构造器的参数无关,适合放每个实例都要、但值不依赖传入参数的东西。静态属性是另一组:定义在类自己身上,而不是单个实例身上,包括静态方法、静态字段、静态 getter 和 setter,也都有私有形式。MDN 的例子是:class Color { static isValid(r, g, b) { return r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255; } },Color.isValid(255, 0, 0) 是 true,Color.isValid(1000, 0, 0) 是 false。静态的和实例的只有两点区别:都以 static 开头,而且实例上读不到,new Color(0, 0, 0).isValid 是 undefined。还有一种静态初始化块:static { MyClass.myStaticProperty = "foo"; },类第一次加载时执行一次,几乎等价于类声明后立刻执行一段代码,唯一的区别是它能访问静态私有元素。MDN 顺带提了一句命名空间的好习惯:工具方法按它处理的东西加前缀,比如 Number.parseInt,比裸的 parseInt 更清楚。咖啡馆的 Dish.isValidPrice 就是静态方法:校验价格合不合法,不需要先造一道菜;每道菜的 name 和 price 是实例字段,new 的时候才定下来。记住判断句:实例的东西挂在实例上,类的东西挂在类上,实例上读不到静态的。
第八步:继承是借行为,super 必须先调
类带来的关键能力,除了私有字段的封装,就是继承:一个对象能“借”另一个对象的大部分行为,再改写或者增强其中一部分。MDN 的例子是 Color 要支持透明度:与其给每个实例都加一个 alpha 字段,不如派生一个子类。写法是:class ColorWithAlpha extends Color { #alpha; constructor(r, g, b, a) { super(r, g, b); this.#alpha = a; } get alpha() { return this.#alpha; } set alpha(value) { if (value < 0 || value > 1) { throw new RangeError("Alpha value must be between 0 and 1"); } this.#alpha = value; } }。语言有一条硬性要求:用 this 之前必须先调 super(),super() 会调用父类的构造器来初始化 this,super 之前可以写别的代码,但不能碰 this。派生类会继承父类的全部方法:ColorWithAlpha 没声明 red 访问器,但 new ColorWithAlpha(255, 0, 0, 0.5).red 还是 255,因为那是父类的行为。派生类也能重写父类的方法:所有类都默认继承 Object 类,toString 默认只会打印 [object Object],子类重写它就能打印颜色的 RGB 值;还可以用 super.toString() 在父类结果上继续加工,返回 "255, 0, 0, 0.5"。静态方法也会继承、也能重写:ColorWithAlpha.isValid(255, 0, 0, -1) 是 false。两条红线:派生类读不到父类的私有字段,this.#values 在子类里是 SyntaxError,私有字段只属于声明它的那个类体;一个类只能 extends 一个类,多重继承的菱形问题就这么被挡住了。咖啡馆的外卖订单就是这么写的:class DeliveryOrder extends Order,super 先把普通订单的字段建好,再加配送地址和配送费;instanceof 两边都认,deliveryOrder instanceof Order 是 true。记住判断句:子类先调 super、再用 this;私有字段不继承,一个类只能继承一个父类。
第九步:原型链就是找属性的路线图
类是语法糖,底下跑的是原型链。MDN 的定义是:JavaScript 对象是动态的“属性包”,每个对象都连着一个原型对象。找一个属性的时候,不光在对象自己身上找,还会在它的原型上找、原型的原型上找,一路找下去,直到找到或者走到链的尽头。MDN 的例子是:const o = { a: 1, b: 2, __proto__: { b: 3, c: 4 } },这条链是 { a: 1, b: 2 } 指向 { b: 3, c: 4 },再指向 Object.prototype,最后是 null。o.a 是 1,自己身上就有;o.b 是 2,自己身上有 b,原型上的 b 是 3,但根本没走到那一步,这叫属性遮蔽;o.c 是 4,自己身上没有,去原型上找到了;o.d 是 undefined,整条链走完都没找到。链可以更长:o 的原型里再嵌一层 { d: 5 },o.d 就是 5,链变成四节。给对象写属性,只会写在自己身上,变成自有属性,只有一个例外:被 getter 或者 setter 拦截的时候。咖啡馆的会员等级就是这么查的:VIP 会员对象自己身上只有名字,折扣去原型上的会员等级里找,找不到再往 Object.prototype 上找,最后是 null。记住判断句:找属性先看自己、再顺链往上找;自己有的会遮住原型上的;走到 null 还没找到,就是 undefined。
第十步:继承的方法里,this 指的是借方法的那个对象
JavaScript 里没有其他语言那种“方法”的形式,任何函数都能以属性的形式挂到对象上,继承来的函数和其他属性一样,也会被遮蔽。关键在 this:继承来的函数执行时,this 指向继承它的对象,而不是函数所在原型对象。MDN 的例子是:const parent = { value: 2, method() { return this.value + 1; } },parent.method() 是 3;const child = { __proto__: parent },child.method() 也是 3,因为调用时 this 是 child,value 先在 child 身上找,找不到再去原型上找 parent.value,也就是 2。给 child 写上自己的 value:child.value = 4,这会在 child 身上新建一个自有属性,遮住原型上的 value,child 现在是 { value: 4, __proto__: { value: 2, method } },再调 child.method() 就是 5。咖啡馆的会员折扣就是这么算的:普通会员的原型上有 discount 方法,读的是 this.level,VIP 会员对象自己写了 level,调同一个方法,算出来的折扣就不一样。记住判断句:方法里的 this 永远是调用者,不是方法住的地方;给子对象写属性,是遮蔽,不是改原型。
第十一步:构造函数的 prototype 是实例的原型
原型真正的威力在于复用:每个实例都该有的方法,放到所有实例的原型上,就不用每个实例存一份。MDN 的盒子例子是:先写一个朴素的版本,三个盒子对象各存一个 getValue,做的事一模一样,纯属浪费;改成一个 boxPrototype 对象挂 getValue,三个盒子都把原型指过去;再往后,手动给每个对象绑原型还是太麻烦,于是用构造函数:function Box(value) { this.value = value; },Box.prototype.getValue = function () { return this.value; },const boxes = [new Box(1), new Box(2), new Box(3)]。new Box(1) 叫从 Box 构造函数创建的实例,Box.prototype 和之前那个 boxPrototype 没什么不同,只是个普通对象;每个用构造函数创建的实例,都会自动把构造函数的 prototype 属性当成自己的原型,也就是 Object.getPrototypeOf(new Box()) === Box.prototype。Box.prototype 默认只有一个自有属性 constructor,指回构造函数本身,Box.prototype.constructor === Box,所以任何实例都能顺着 constructor 找到原来的构造函数。类写法和这套完全对应:class Box { constructor(value) { this.value = value; } getValue() { return this.value; } },方法就是建在 Box.prototype 上的,MDN 的原话是:类是构造函数之上的语法糖。还有一个推论:改 Box.prototype,所有实例的行为都会变,哪怕实例已经创建好了。MDN 的例子是:const box = new Box(1),事后把 Box.prototype.getValue 改成返回 this.value + 1,box.getValue() 就是 2。但反过来,直接给 Constructor.prototype 重新赋值是坏主意,MDN 给了两个理由:之前创建的实例和之后创建的实例,原型指向了不同的对象,再改原型就各改各的;除非手动把 constructor 属性设回去,否则实例上再也找不到原来的构造函数,有些内置操作读 constructor 属性也会出问题。咖啡馆的菜品类就是这么维护的:Dish.prototype.format 挂在原型上,所有菜共用;哪天想改菜品的显示格式,改一处原型,全站的菜都跟着变。记住判断句:实例的原型就是构造函数的 prototype;改原型,所有实例一起变;别重赋值 prototype。
第十二步:字面量自带原型,数组方法就住在 Array.prototype 上
有些字面量语法创建实例的时候,会悄悄把原型定好。MDN 的例子是:const object = { a: 1 },Object.getPrototypeOf(object) === Object.prototype 是 true;const array = [1, 2, 3],原型是 Array.prototype;const regexp = /abc/,原型是 RegExp.prototype。它们都能脱糖成构造函数的写法:new Array(1, 2, 3)、new RegExp("abc")。所以“数组方法”其实就是定义在 Array.prototype 上的方法,这就是为什么所有数组实例自动就有 map。原型链还有一节容易混淆的:Constructor.prototype 只在创建实例的时候有用,它和 Constructor 自己的原型是两回事——构造函数的原型是 Function.prototype,Object.getPrototypeOf(Constructor) === Function.prototype。典型的构造函数的原型链是:obj 指向 Constructor.prototype,再指向 Object.prototype,最后是 null;想拉长这条链,用 Object.setPrototypeOf(Derived.prototype, Base.prototype),等价于 class 里写 extends。MDN 还点名了一种老代码的写法:Derived.prototype = Object.create(Base.prototype),它会重新赋值 prototype 属性、丢掉 constructor 属性,更容易出错,别这么写,用 Object.setPrototypeOf 去改。咖啡馆的订单列表就是这么理解的:orders.map 能直接用,是因为 orders 的原型是 Array.prototype,map 就住在那上面。记住判断句:字面量自带原型;数组方法住在 Array.prototype 上;Constructor.prototype 和 Constructor 自己的原型不是一回事。
第十三步:Object.create、setPrototypeOf 与猴子补丁的红线
MDN 系统总结了几种指定原型的办法。字面量:const o = { a: 1 },链是 o 指向 Object.prototype 再指向 null;数组 b = ["yo", "sup", "?"],链是 b 指向 Array.prototype 再指向 Object.prototype 再指向 null;函数 f,链是 f 指向 Function.prototype 再指向 Object.prototype 再指向 null;__proto__ 字面量键:const p = { b: 2, __proto__: o },链是 p 指向 o 再指向 Object.prototype 再指向 null。Object.create 直接指定新对象的原型:const b = Object.create(a),链是 b 指向 a 再指向 Object.prototype 再指向 null;Object.create(null) 造出来的对象原型直接就是 null,连 hasOwnProperty 都没有,d.hasOwnProperty 是 undefined。Object.setPrototypeOf 能改一个已有对象的原型,甚至能给 Object.create(null) 造出来的对象强加一个原型、或者把原型改成 null,但 MDN 提醒:创建时定好原型最好,动态改原型会打乱引擎对原型链做的所有优化,可能让引擎重新编译代码。obj.__proto__ 那个访问器是非标准的、已废弃的,几乎总是应该用 Object.setPrototypeOf 代替。还有一条红线:扩展内置原型,MDN 称之为猴子补丁,比如定义 Array.prototype.myMethod 再到处用。风险是语言以后加了同名方法但签名不同,你的代码就断了,历史上出过 SmooshGate 这样的事故;唯一正当的理由,是给新引擎的功能做向后兼容。咖啡馆的代码规范就写了这一条:业务代码不许碰 Array.prototype、Object.prototype,想加工具方法,写成独立函数或者挂到自己的类上。记住判断句:原型创建时定好;Object.create(null) 的对象连 hasOwnProperty 都没有;内置原型不许乱扩展。
第十四步:长链有代价,查自有属性用 hasOwnProperty
原型链不是越长越好。MDN 提醒了两点代价:第一,链上位置越高的属性,查找时间越长,性能关键的代码里这可能很明显;访问不存在的属性更要走完整条链。第二,遍历对象属性的时候,原型链上所有可枚举的属性都会被枚举出来。想判断一个属性是不是对象自己的、而不是从原型链上继承来的,得用 hasOwnProperty 或者 Object.hasOwn。MDN 的 Graph 例子是:function Graph() { this.vertices = []; this.edges = []; },Graph.prototype.addVertex = function (v) { this.vertices.push(v); },const g = new Graph(),链是 g 指向 Graph.prototype 再指向 Object.prototype 再指向 null。g.hasOwnProperty("vertices") 是 true,Object.hasOwn(g, "vertices") 是 true;g.hasOwnProperty("nope") 是 false;g.hasOwnProperty("addVertex") 是 false,因为 addVertex 是原型上的,Object.getPrototypeOf(g).hasOwnProperty("addVertex") 才是 true。MDN 还提醒:只看属性是不是 undefined 是不够的,属性可能存在、值恰好就是 undefined。还有一个全貌要记:所有构造函数都有一个叫 prototype 的特殊属性,和 new 运算符一起工作;new 一个实例的时候,JavaScript 先在内存里创建对象、把实例的原型设成 A.prototype,再运行构造函数 A;之后访问实例的属性,先看对象自己,再看原型,一路递归,直到找到或者 Object.getPrototypeOf 返回 null;所有在 prototype 上定义的属性,实际上由所有实例共享,甚至事后改 prototype,已有的实例也会跟着变。MDN 的结尾还给了使用建议:类适合用来组织代码,特别是想创建“自己存内部数据、又暴露很多行为”的对象,比如 Map 和 Set 存一批元素、用 get、set、has 操作,Date 存一个时间戳、能格式化和读写各个部分,Error 存错误信息和堆栈,TypeError、ReferenceError 这些内置错误类继承 Error,instanceof 一查就知道是哪种错。咖啡馆的会员系统就是按这个建议收的尾:会员类存余额和等级,暴露 recharge、spend、discount 这些行为;链保持两到三节,不拉更长。记住判断句:链越长、找得越慢;查自有属性用 hasOwnProperty,别只看是不是 undefined。
第十五步:110 次类与原型链事故,先对着图自查

上图是虚构的青石咖啡馆项目一个月的统计:和类与原型链相关的事故一共 110 次。忘写 new、直接调用类 28 次,占 25.5%,是最多的;把方法写进构造函数、每个实例一份新函数 22 次,占 20.0%;子类忘调 super 就用 this 19 次,占 17.3%;直接改私有数据、绕过 setRed 里面的校验 16 次,占 14.5%;改了原型上的方法、所有实例一起变 14 次,占 12.7%;给实例挂属性、以为改了原型 11 次,占 10.0%。28 加 22 加 19 加 16 加 14 加 11 等于 110,账是平的。这些数字是编出来的例子,目的是让你一眼看到:第一类占了四分之一还多,而它的根源只有一个——类不是函数,不用 new 就不能调用。
自查清单:写完带类的代码,逐条打勾
第一,new 造实例,实例带数据和方法,类自己也带一份;类先声明、后使用,造实例一定写 new。第二,构造器只管往 this 上挂数据,别返回值;每次 new 都是新实例。第三,方法写在类体里,所有实例共用一份;写在构造器里,每个实例一份新的。第四,内部数据加 #,校验写进方法里,别把裸数据递到用户手上;同类实例之间能读对方的私有字段。第五,get 加 set 是可读写属性,只有 get 是只读属性;严格模式下给只读属性赋值会抛错。第六,实例的东西挂在实例上,类的东西挂在类上,实例上读不到静态的。第七,子类先调 super、再用 this;私有字段不继承,一个类只能继承一个父类;重写方法可以用 super 接着父类的结果往下写。第八,找属性先看自己、再顺链往上找;自己有的会遮住原型上的;走到 null 还没找到,就是 undefined。第九,方法里的 this 永远是调用者,不是方法住的地方;给子对象写属性,是遮蔽,不是改原型。第十,实例的原型就是构造函数的 prototype;改原型,所有实例一起变;别重赋值 prototype。第十一,字面量自带原型,数组方法住在 Array.prototype 上;Constructor.prototype 和 Constructor 自己的原型不是一回事。第十二,原型创建时定好;Object.create(null) 的对象连 hasOwnProperty 都没有;内置原型不许乱扩展。第十三,链越长、找得越慢;查自有属性用 hasOwnProperty,别只看是不是 undefined。十三条里任何一条答不上来,回到对应的章节再读一遍,比多背十个 API 都有用。
评论 (0)
原始来源
相关文章
函数你每天都在调,这篇把你一直在做的事讲清楚。本文按 MDN 的《Functions》《Arrow function expressions》《Rest parameters》三篇官方文档讲清楚:声明与表达式、参数与实参、默认值、剩余参数、展开语法、返回值、箭头函数省写规则、this 的坑、回调与高阶函数、作用域。
同一个页面要在手机、平板、电脑上都站得住。本文按 MDN 的《Responsive web design》《Using media queries》《viewport meta 参考》三篇官方文档讲清楚:流式 HTML、viewport 标签、流式网格与 max-width、图片不撑破容器、媒体查询语法、按内容定断点、mobile-first、响应式字号、按能力查设备与上线检查清单。
JavaScript 里数字只有一种类型 Number,存成 64 位浮点数,所以 0.1 + 0.2 等于 0.30000000000000004。本文按 MDN 的《Basic math in JavaScript》《Math》《Number》三篇官方文档讲清楚:一种数字类型、浮点误差、钱改成分算、字符串转数字、NaN 与 Infinity、安全整数、四种取整、Math.random、Math 工具箱与显示格式化。