第一章：从原型到类继承，深度剖析JavaScript面向对象底层机制
JavaScript的面向对象机制与传统基于类的语言存在本质差异。其核心依赖于原型（prototype）链实现对象间的属性查找与方法继承，而非类的静态结构。尽管ES6引入了class语法糖，但底层仍基于原型机制运作。
原型链的工作原理
每个JavaScript对象都拥有一个内部属性[[Prototype]]，指向其原型对象。当访问某对象的属性时，若该对象本身不存在该属性，则引擎会沿着原型链向上查找，直至找到匹配属性或到达原型链末端（null）。
// 构造函数与原型关系示例
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
return `Hello, I'm ${this.name}`;
};
const alice = new Person("Alice");
console.log(alice.greet()); // 输出: Hello, I'm Alice
// greet 方法在 Person.prototype 上，通过原型链调用
类语法背后的真相
ES6中的class关键字仅为语法糖，其定义的“类”本质上仍是构造函数，继承通过extends和super实现，底层依旧依赖原型链。
class声明提升但不初始化，存在暂时性死区- 类中定义的方法默认不可枚举
- 静态方法挂载在构造函数自身上，而非原型
继承机制对比
| 特性 | 原型继承 | class继承 |
|---|---|---|
| 语法复杂度 | 较高 | 较低 |
| 可读性 | 较差 | 良好 |
| 底层机制 | 直接操作prototype | 基于prototype的封装 |
graph TD
A[Object] --> B[Function]
B --> C[Person]
C --> D[Alice]
style A fill:#f9f,stroke:#333
style D fill:#bbf,stroke:#333
第二章：理解JavaScript原型与原型链
2.1 原型对象的本质与constructor属性解析
JavaScript中的原型对象是实现继承和共享属性的核心机制。每个函数在创建时都会自动生成一个`prototype`属性，指向一个包含`constructor`属性的对象，该对象即为原型对象。constructor属性的来源与作用
function Person(name) {
this.name = name;
}
console.log(Person.prototype.constructor === Person); // true
原型链中的constructor行为
- 实例通过
__proto__访问原型对象 - 原型对象的
constructor保持对构造函数的引用 - 重写原型时需手动修复
constructor指向
constructor关系将丢失，必须显式恢复：
Person.prototype = {
greet() { console.log("Hello"); }
};
// 此时 Person.prototype.constructor 不再指向 Person
Object.defineProperty(Person.prototype, 'constructor', {
value: Person,
enumerable: false,
writable: true
});
constructor的逻辑出错。
2.2 __proto__与prototype：连接实例与构造函数的桥梁
JavaScript中的对象继承机制依赖于`__proto__`与`prototype`之间的关联。每个函数创建时都会自动生成一个`prototype`对象属性，而通过该函数构造的实例则会通过`__proto__`指向这个`prototype`。原型链连接原理
当使用构造函数创建实例时，实例的内部指针`[[Prototype]]`（可通过`__proto__`访问）被设置为构造函数的`prototype`属性。function Person(name) {
this.name = name;
}
const alice = new Person("Alice");
console.log(alice.__proto__ === Person.prototype); // true
原型属性共享机制
通过原型定义的方法和属性可被所有实例共享：- 构造函数的
prototype用于挂载共享方法 - 实例通过
__proto__动态查找原型成员 - 修改
prototype会影响所有现存及未来实例
2.3 原型链的查找机制与属性遮蔽现象
JavaScript 在访问对象属性时，会首先检查对象自身是否包含该属性。若不存在，则沿着原型链向上逐级查找，直到找到对应属性或抵达原型链末端（即null）为止。
属性查找过程示例
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
return `Hello, I'm ${this.name}`;
};
const alice = new Person("Alice");
console.log(alice.greet()); // 输出: Hello, I'm Alice
alice 实例本身没有 greet 方法，但通过原型链访问到 Person.prototype 上的方法。
属性遮蔽现象
当对象自身定义了与原型同名的属性时，会屏蔽原型中的属性：- 赋值操作在对象自身创建属性，不会修改原型
- 读取时优先返回自身属性，导致原型属性被“遮蔽”
2.4 手动构建原型链模拟继承关系
在 JavaScript 中，原型链是实现对象间继承的核心机制。通过手动设置构造函数的原型，可以模拟类的继承行为。基本实现方式
使用构造函数和原型属性手动连接对象之间的继承关系：
function Animal(name) {
this.name = name;
}
Animal.prototype.speak = function() {
console.log(this.name + ' 发出声音');
};
function Dog(name) {
Animal.call(this, name); // 继承实例属性
}
Dog.prototype = Object.create(Animal.prototype); // 建立原型链
Dog.prototype.constructor = Dog;
const dog = new Dog('旺财');
dog.speak(); // 输出：旺财 发出声音
继承链验证
- Dog.prototype.__proto__ 指向 Animal.prototype
- dog instanceof Dog 和 dog instanceof Animal 均返回 true
2.5 原型链中的性能考量与最佳实践
在JavaScript中，原型链的深度直接影响属性查找的性能。过深的继承链会导致引擎在查找属性时遍历更多对象，增加时间开销。避免过长的原型链
建议继承层级控制在2-3层以内，以减少查找延迟。深层继承不仅影响性能，还降低代码可维护性。使用Object.create(null)优化
当不需要继承Object.prototype时，可使用Object.create(null)创建无原型对象，提升属性访问速度。
const plainObj = Object.create(null);
plainObj.data = 'optimized';
// 优势：无原型链查找，直接访问自身属性
hasOwnProperty检查开销。
- 优先使用组合而非深层继承
- 缓存频繁访问的原型属性引用
- 避免在热路径中进行原型扩展
第三章：构造函数与对象创建模式
3.1 构造函数的工作原理与new关键字内部机制
JavaScript 中的构造函数本质上是一个普通函数，但遵循特定约定：首字母大写，并通过 `new` 关键字调用。当使用 `new` 操作符时，JavaScript 引擎会自动执行以下步骤。new 关键字的四步执行机制
- 创建一个空对象（即 `{}`），并将其隐式关联为函数的实例；
- 将构造函数的 `this` 指向这个新对象；
- 执行构造函数体内的代码，为新对象添加属性和方法；
- 若构造函数未返回非原始类型对象，则自动返回该新对象。
代码示例与解析
function Person(name) {
this.name = name; // this 指向新创建的对象
}
const p = new Person("Alice");
new Person("Alice") 创建了一个新对象，并将 this.name 绑定到该对象。最终 p.name === "Alice" 成立，表明构造函数成功初始化了实例。
3.2 工厂模式与构造函数模式的对比分析
核心设计思想差异
工厂模式通过函数封装对象创建过程，侧重解耦实例化逻辑；构造函数模式则依赖new 操作符和原型链，强调类型标识与继承机制。
代码实现对比
// 工厂模式
function createPerson(name) {
return {
name: name,
greet() { console.log(`Hi, I'm ${this.name}`); }
};
}
// 构造函数模式
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
console.log(`Hi, I'm ${this.name}`);
};
new 调用，灵活性高但无法识别统一类型；构造函数需使用 new，实例共享原型方法，利于内存优化且支持 instanceof 判断。
适用场景对比
- 工厂模式适合复杂对象构建，隐藏内部细节
- 构造函数模式适用于需要明确类型关系和原型扩展的场景
3.3 寄生构造函数与稳妥构造函数的应用场景
寄生构造函数模式的使用时机
寄生构造函数模式适用于需要在不修改原有构造函数的前提下，扩展对象属性或方法的场景。该模式通过在构造函数内部创建新对象并返回，实现灵活的对象创建。
function SpecialArray() {
const arr = new Array();
arr.push.apply(arr, arguments);
arr.toPipedString = function() {
return this.join('|');
};
return arr; // 返回新对象
}
const colors = new SpecialArray('red', 'blue', 'green');
console.log(colors.toPipedString()); // "red|blue|green"
上述代码中，SpecialArray 返回了一个数组实例，并附加了自定义方法。尽管使用 new 调用，但实际返回的是内部创建的对象，与原构造函数无关。
稳妥构造函数的安全优势
稳妥构造函数用于确保对象在严格安全环境下运行，避免使用 this 和 new，防止外部访问内部数据。
- 不依赖
this引用实例属性 - 禁止通过
new或直接调用暴露私有变量 - 适合在不可信执行环境中使用
第四章：现代JavaScript类与继承实现
4.1 class语法糖背后的原型机制还原
JavaScript中的class是ES6引入的语法糖，其底层仍基于原型（prototype）机制实现。通过class定义的类，本质上是构造函数的另一种写法。class与构造函数的等价性
class Person {
constructor(name) {
this.name = name;
}
greet() {
return `Hello, I'm ${this.name}`;
}
}
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
return `Hello, I'm ${this.name}`;
};
原型链结构对比
| 特性 | class写法 | 原型写法 |
|---|---|---|
| 构造函数 | constructor | Person() |
| 方法存储位置 | Person.prototype | Person.prototype |
| 实例继承 | __proto__指向Person.prototype | 同左 |
4.2 extends与super：类继承的语义化封装
在面向对象编程中，`extends` 和 `super` 构成了类继承的核心机制。通过 `extends` 关键字，子类可继承父类的属性与方法，实现代码复用。继承的基本语法
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(`${this.name} 发出声音`);
}
}
class Dog extends Animal {
constructor(name, breed) {
super(name); // 调用父类构造函数
this.breed = breed;
}
speak() {
super.speak(); // 调用父类方法
console.log(`${this.name} 汪汪叫`);
}
}
super 的调用规则
- 在子类构造函数中，必须在使用
this前调用super() super.method()可访问父类的实例方法super()必须仅在子类构造函数中调用一次
4.3 静态方法与实例方法的底层绑定逻辑
在Java虚拟机（JVM）中，静态方法与实例方法的调用机制存在本质差异。静态方法属于类本身，其调用通过`invokestatic`指令完成，在编译期即可确定目标方法地址，无需依赖对象实例。调用指令对比
invokestatic：用于静态方法调用，绑定发生在类加载的解析阶段；invokevirtual：用于实例方法调用，支持多态，绑定延迟至运行时。
代码示例与分析
public class MathUtils {
public static int add(int a, int b) {
return a + b; // 静态方法
}
public int multiply(int a, int b) {
return a * b; // 实例方法
}
}
add()可通过类名直接调用，JVM在方法区中查找其符号引用并解析为直接引用；而multiply()必须通过对象实例调用，其调用过程涉及虚方法表（vtable）查找，实现动态分派。
4.4 使用Babel剖析class转译为ES5的过程
JavaScript中的`class`语法是ES6引入的语法糖，底层仍基于原型继承。Babel可将`class`编写的代码转换为兼容性更强的ES5代码。源码示例
class Person {
constructor(name) {
this.name = name;
}
sayHello() {
return `Hello, I'm ${this.name}`;
}
}
Babel转译结果
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
var Person = function Person(name) {
_classCallCheck(this, Person);
this.name = name;
};
Person.prototype.sayHello = function sayHello() {
return "Hello, I'm " + this.name;
};
第五章：JavaScript面向对象机制的演进与未来展望
类语法的引入与实际应用
ES6 引入的 class 语法极大提升了代码可读性，尽管其本质仍是原型继承的语法糖。以下示例展示了现代类的封装方式：
class Vehicle {
constructor(brand) {
this.brand = brand;
}
start() {
console.log(`${this.brand} engine started`);
}
}
class Car extends Vehicle {
constructor(brand, model) {
super(brand);
this.model = model;
}
drive() {
console.log(`Driving ${this.brand} ${this.model}`);
}
}
const myCar = new Car("Tesla", "Model S");
myCar.start(); // Tesla engine started
myCar.drive(); // Driving Tesla Model S
私有字段与封装增强
JavaScript 正式支持私有字段，使用# 前缀定义，避免外部意外访问。
- 私有字段在构造函数中声明，提升数据安全性
- 适用于敏感状态管理，如缓存、连接状态等
- 结合 getter/setter 实现受控访问
装饰器的实验性前景
装饰器（Decorators）提案允许在类和成员上添加元编程逻辑，已被部分框架（如 Angular、NestJS）广泛采用。| 特性 | 当前状态 | 应用场景 |
|---|---|---|
| 静态类初始化 | Stage 3 提案 | AOP、日志、权限校验 |
| 方法拦截 | 实验性支持 | 性能监控、参数验证 |
基于原型的优化策略
尽管 class 语法普及，理解原型链仍至关重要。V8 引擎对原型属性访问进行内联缓存（IC），合理设计原型结构可提升运行时性能。
推荐将通用方法挂载到 prototype，而非实例，减少内存占用。
175
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
