js怎么用原型实现方法共享

javascript中实现方法共享的核心机制是原型链，即通过构造函数的prototype对象存储方法，使所有实例共享同一份方法代码，避免内存浪费。1. 当方法定义在构造函数内部时，每个实例都会创建独立的方法副本，导致内存开销大；2. 而通过原型链，方法只在prototype上定义一次，实例通过[[prototype]]链接向上查找调用，实现高效复用；3. 方法调用时this指向实际调用者（即实例对象），而非原型本身，确保方法能正确访问实例属性。这种机制不仅节省内存，还提升性能，是javascript对象模型的关键设计。

JavaScript中，实现方法共享的核心机制就是“原型链”。简单来说，我们不是在每个对象实例内部都复制一份方法，而是把这些方法定义在一个共享的“原型”对象上。当一个实例需要调用某个方法时，它会沿着原型链向上查找，直到找到并执行这个方法。这样一来，所有实例都能高效地复用同一份方法代码，极大地节省了内存开销。

在我看来，理解JavaScript的原型，就像是理解一个家族的遗传基因。每个家族成员（实例）都有自己的独特之处，但他们也共享着家族的某些特征或技能（方法），这些技能并不是每个人都独立学习一遍，而是家族的“传统”或“遗产”里就有的。

具体到代码层面，我们通常会通过构造函数的

prototype

属性来添加共享方法。当一个函数被用作构造函数（通过

new

关键字调用）时，它创建的每个实例都会自动获得一个指向该构造函数

prototype

对象的内部链接（

[[Prototype]]

，在多数浏览器中表现为

__proto__

）。

举个例子：

function Person(name, age) {     this.name = name;     this.age = age; }  // 将方法添加到Person的原型上 Person.prototype.greet = function() {     console.log(`你好，我叫${this.name}，今年${this.age}岁。`); };  Person.prototype.celebrateBirthday = function() {     this.age++;     console.log(`${this.name}庆祝了生日，现在${this.age}岁了！`); };  const person1 = new Person('张三', 30); const person2 = new Person('李四', 25);  person1.greet(); // 你好，我叫张三，今年30岁。 person2.greet(); // 你好，我叫李四，今年25岁。  person1.celebrateBirthday(); // 张三庆祝了生日，现在31岁了！ person1.greet(); // 你好，我叫张三，今年31岁。

你看，

greet

和

celebrateBirthday

方法只在内存中存在一份，所有

Person

的实例都能调用它们。这不就实现了方法共享嘛。

为什么我们需要方法共享？不共享会有什么问题？

这个问题，我个人觉得是理解JavaScript对象模型的一个关键点。试想一下，如果你不使用原型共享，而是把方法直接定义在构造函数内部，会发生什么？

function BadPerson(name, age) {     this.name = name;     this.age = age;     // 每次创建实例，都会重新创建这些方法     this.greet = function() {         console.log(`你好，我叫${this.name}，今年${this.age}岁。`);     };     this.celebrateBirthday = function() {         this.age++;         console.log(`${this.name}庆祝了生日，现在${this.age}岁了！`);     }; }  const badPerson1 = new BadPerson('王五', 40); const badPerson2 = new BadPerson('赵六', 35);  console.log(badPerson1.greet === badPerson2.greet); // false

看到没？

badPerson1.greet

和

badPerson2.greet

是两个完全不同的函数对象，即使它们做的事情一模一样。如果你的应用需要创建成千上万个

BadPerson

实例，那么每个实例都会带着它自己的一套方法副本。这会带来非常明显的内存浪费，同时，创建实例的速度也会变慢，因为每次都要执行函数创建的操作。

这就像是，你每买一辆新车，就重新发明一次轮子。这显然是不划算的。方法共享就是为了避免这种不必要的重复劳动，让代码更高效、更优雅。

原型链是如何让方法共享成为可能的？

这真是JavaScript里最巧妙也最容易让人混淆的地方之一。简单来说，每个JavaScript对象都有一个内部属性，指向它的原型对象。当你在一个对象上访问一个属性或方法时，如果该对象本身没有这个属性或方法，JavaScript引擎就会沿着这个内部链接（也就是原型链）向上查找，直到找到这个属性或方法，或者查到原型链的顶端（

null

）。

用之前的

Person

例子来说：

1. person1

   是一个

   Person

   的实例。

2. 当你调用

   person1.greet()

   时，JavaScript首先在

   person1

   对象自身查找

   greet

   方法。

3. person1

   对象自身没有

   greet

   方法。

4. 于是，JavaScript通过

   person1

   的内部

   [[Prototype]]

   链接（即

   person1.__proto__

   ）找到

   Person.prototype

   对象。

5. 在

   Person.prototype

   上找到了

   greet

   方法。

6. 执行

   Person.prototype.greet

   方法。

这条查找路径就是原型链。

Person.prototype

对象自身也有一个

[[Prototype]]

，它指向

Object.prototype

。

Object.prototype

是原型链的终点（它的

[[Prototype]]

是

null

）。这意味着，所有JavaScript对象都能访问

Object.prototype

上的方法，比如

toString()

、

hasOwnProperty()

等。

console.log(person1.__proto__ === Person.prototype); // true console.log(Person.prototype.__proto__ === Object.prototype); // true console.log(Object.prototype.__proto__); // null

通过这种层层递进的查找机制，方法得以在多个对象之间共享，而无需在每个对象上都复制一份。这是一种非常高效且灵活的继承方式。

共享方法时，

this

指向问题如何处理？

这块内容，我觉得是原型方法共享里一个非常实用且必须搞清楚的点。很多初学者在这里容易犯迷糊，觉得既然方法定义在原型上，那

this

会不会指向原型对象本身呢？答案是：不会。

在JavaScript中，

this

的指向是在函数被调用时确定的，而不是在函数定义时。当一个原型上的方法被一个实例调用时，

this

会自动指向那个调用该方法的实例对象。

继续用

Person

的例子：

Person.prototype.greet = function() {     // 这里的this指向调用greet方法的实例     console.log(`你好，我叫${this.name}，今年${this.age}岁。`); };  const person1 = new Person('张三', 30); const person2 = new Person('李四', 25);  person1.greet(); // 当person1调用时，this就是person1 person2.greet(); // 当person2调用时，this就是person2

你看，

greet

方法虽然只有一个副本，但它能正确地获取到调用者（

person1

或

person2

）的

name

和

age

属性。这是因为

this

在运行时被动态绑定到了调用它的对象上。

这种机制使得原型方法非常强大和灵活，它们可以作用于任何调用它们的实例，处理实例特有的数据。这也就是为什么我们能用一套方法模板，去操作无数个具体的数据实例。当然，如果你用

call

、

apply

、

bind

或者箭头函数（ES6）去显式地改变

this

的绑定，那又是另一回事了，但对于常规的原型方法调用，

this

总是指向实例。理解这一点，对于编写健壮的JavaScript代码至关重要。