原型链是JavaScript实现继承的核心机制，它通过对象的__proto__属性与构造函数的prototype属性链接，形成一条属性查找链。当访问对象属性时，若自身不存在，则沿原型链向上搜索，直至Object.prototype或null。prototype是函数独有的属性，指向实例的共享原型对象；__proto__是每个对象都有的内部属性，指向其构造函数的prototype。将方法定义在prototype上可实现内存共享，提升性能；通过Object.create()可构建继承关系，实现行为复用。原型链的动态性允许运行时修改共享方法，所有实例即时生效，但应避免修改内置对象原型以防冲突。理解原型链有助于写出高效、可维护的JavaScript代码。
原型链是JavaScript中实现继承的核心机制，它允许对象从其他对象那里继承属性和方法。简单来说，当你尝试访问一个对象的某个属性或方法时，如果这个对象本身没有，JavaScript就会沿着一条由内部链接组成的“链条”向上查找，直到找到该属性或方法，或者查到链的尽头（通常是
null）。这个查找的过程和链条本身，就是原型链。原型继承的原理，正是基于这种通过原型链进行属性查找和共享的机制。
JavaScript里，每个对象都有一个内部链接，指向另一个对象，这个被链接的对象就是它的“原型”（prototype）。当你在一个对象上访问一个属性时，如果它自身没有这个属性，JavaScript就会去它的原型上找。如果原型也没有，就继续找原型的原型，如此往复，直到找到
Object.prototype（大多数对象的原型链最终都会指向这里），如果还没找到，那就返回
undefined。这个查找路径，就是原型链在起作用。
举个例子，你创建一个构造函数，比如
function Person(name) { this.name = name; }。然后你用new Person('张三')创建了一个实例zhangsan。这个
zhangsan对象会有一个内部链接（也就是我们常说的
__proto__），指向
Person.prototype这个对象。如果你在
zhangsan上调用一个方法，比如
zhangsan.sayHello()，而
zhangsan本身没有
sayHello方法，JavaScript就会去
Person.prototype上找。如果
Person.prototype上有，那就用它。如果
Person.prototype也没有，那它也会有自己的
__proto__指向
Object.prototype，查找就会继续下去。这种层层递进的关系，构建了原型链，也成就了JavaScript的继承。
__proto__
和 prototype
有什么区别？
这是很多初学者都会犯迷糊的地方，也确实是理解原型链的关键所在。简单点说，
prototype是一个函数才有的属性，它指向一个对象，这个对象就是未来通过该函数构造出来的所有实例的公共祖先。你可以把所有共享的方法和属性都放在这个
prototype对象上。比如，
Person.prototype就是所有
Person实例的“共享仓库”。
而
__proto__（注意，这是个非标准的属性，虽然现代浏览器都支持，但更推荐使用
Object.getPrototypeOf()和
Object.setPrototypeOf()）则是每个对象实例都有的属性，它指向创建这个实例的构造函数的
prototype对象。所以，当你创建一个
zhangsan对象，它的
zhangsan.__proto__就指向
Person.prototype。这就像是，
prototype是图纸，而
__proto__是根据图纸造出来的每件产品上，那个指向图纸的标记。一个在函数身上，一个在对象实例身上，作用完全不同，但又紧密相连，共同构成了原型链。
为什么说原型链是JavaScript实现继承的核心？
我觉得，把原型链看作JavaScript实现继承的核心，是因为它提供了一种非常灵活且高效的机制，与传统的基于类的继承模型截然不同。在JavaScript中，没有像Java或C++那样的“类”的概念（ES6的
class语法也只是语法糖，底层依然是原型链）。所有的对象都是通过原型链相互关联，从而实现属性和方法的共享。
这种机制的妙处在于：
-
资源共享与节约内存： 想象一下，如果你有成千上万个
Person
实例，每个实例都有一个sayHello
方法。如果这个方法直接定义在每个实例内部，那内存消耗会非常大。但如果把sayHello
定义在Person.prototype
上，所有实例都通过原型链共享同一个方法，大大节约了内存。这对于大规模应用来说，是实实在在的性能提升。 -
动态性： 原型链是动态的。你可以在运行时修改一个构造函数的
prototype
对象，比如添加一个新的方法。那么，所有基于这个构造函数创建的实例（包括那些已经创建的），都会立即“继承”到这个新的方法。这种灵活性是类继承模型很难比拟的。 - 行为复用： 它让代码复用变得简单直接。你不需要复杂的类层次结构，只需要通过设置对象的原型，就能让它拥有另一个对象的行为。
所以，原型链不仅仅是一种技术实现，它更是JavaScript这门语言设计哲学的一部分，强调对象的关联而非僵硬的分类。
实际开发中，我们如何利用原型链进行优化？
在实际开发中，理解并恰当利用原型链，确实能帮助我们写出更高效、更易维护的代码。
一个最常见的优化点就是将方法定义在构造函数的prototype
上。而不是直接在构造函数内部用
this.method = function() {}的方式定义。// 不推荐：每次创建实例都会生成新的方法
function DogBad(name) {
this.name = name;
this.bark = function() {
console.log(this.name + ' says woof!');
};
}
// 推荐：方法定义在原型上，所有实例共享
function DogGood(name) {
this.name = name;
}
DogGood.prototype.bark = function() {
console.log(this.name + ' says woof!');
};
const dog1 = new DogGood('Buddy');
const dog2 = new DogGood('Lucy');
dog1.bark(); // Buddy says woof!
dog2.bark(); // Lucy says woof!
// console.log(dog1.bark === dog2.bark); // true，因为它们引用的是同一个函数通过这种方式，
bark方法只在内存中存在一份，所有
DogGood的实例都通过原型链去访问它，大大减少了内存开销。
另外，在某些场景下，我们可以利用原型链实现简单的继承。比如：
function Animal(name) {
this.name = name;
}
Animal.prototype.eat = function() {
console.log(this.name + ' is eating.');
};
function Cat(name) {
Animal.call(this, name); // 继承父类的属性
}
// 核心：设置Cat的原型链，使其指向Animal的实例
// 这样Cat的实例就能通过原型链访问到Animal.prototype上的方法
Cat.prototype = Object.create(Animal.prototype);
Cat.prototype.constructor = Cat; // 修正constructor指向
Cat.prototype.meow = function() {
console.log(this.name + ' says meow!');
};
const myCat = new Cat('Tom');
myCat.eat(); // Tom is eating. (继承自Animal.prototype)
myCat.meow(); // Tom says meow! (Cat自身的方法)这里
Object.create(Animal.prototype)是关键，它创建了一个新对象，并把这个新对象的
__proto__指向了
Animal.prototype。然后我们把
Cat.prototype指向这个新对象，这样就建立起了
Cat实例到
Animal.prototype的原型链。修正
constructor属性也很重要，否则所有
Cat实例的
constructor会指向
Animal。
当然，也有一些需要谨慎对待的地方。比如，不推荐直接修改内置对象（如Array.prototype
、Object.prototype
）的原型，除非你非常清楚自己在做什么。因为这可能会导致“污染”全局环境，与其他库或未来的JavaScript版本产生冲突，引发难以预料的bug。
总的来说，原型链是JavaScript的基石，理解它能让你更深入地掌握这门语言，写出更符合其设计哲学的代码，从而在性能和维护性上都有所提升。
