JS原型链默认值获取方法

理解JavaScript原型链是掌握JS的关键。本文深入探讨了如何通过原型链获取默认值，实际上是通过属性查找机制实现的。当访问对象属性时，若对象自身不存在，JS会沿原型链向上查找。文章还讲解了如何使用`Object.prototype.hasOwnProperty()`判断属性来源，避免原型链属性带来的潜在问题，如共享引用类型修改和属性遮蔽。此外，还探讨了原型链在实际开发中的应用，如共享方法、实现继承，并强调了避免修改内置对象原型的重要性，旨在帮助开发者更好地利用原型链特性，编写高效、结构化的代码，提升网站的SEO优化。

JavaScript中“获取原型链上的默认值”并非主动获取，而是通过属性查找机制在对象自身不存在该属性时，自动沿原型链向上搜索直到找到或到达链尾；2. 判断属性是否来自原型链而非自身，应使用Object.prototype.hasOwnProperty()方法，若返回false则说明属性继承自原型链；3. 修改原型链上的属性可能引发共享引用类型导致的意外修改和属性遮蔽带来的逻辑混乱，尤其在多个实例间共享可变对象时需格外谨慎；4. 实际开发中应利用原型链共享方法以节省内存、实现继承结构、提供可覆盖的默认配置，但避免修改内置对象原型，确保实例独有数据与共享行为分离。

JavaScript里说“获取原型链上的默认值”，这说法挺有意思的。其实JS并没有一个专门的“默认值”概念等着你去取，它更像是一种查找机制。当你尝试访问一个对象的某个属性时，如果这个对象本身没有这个属性，JS引擎就会顺着它的原型链往上找，直到找到或者找到头（也就是null）。所以，你最终拿到的那个值，如果不是对象自身的，那它就是来自原型链上的某个“默认”——因为它在那里，等待被继承或被覆盖。

解决方案

理解JavaScript如何通过原型链查找属性是关键。当你写myObject.someProperty时，JavaScript会先看看myObject自身有没有someProperty。如果没有，它就会去myObject的原型（也就是Object.getPrototypeOf(myObject)）上找。如果原型上也没有，它会继续往原型的原型上找，直到找到这个属性或者原型链的顶端（通常是Object.prototype，再往上就是null）。找到的第一个值就是你要的。

所以，“获取原型链上的默认值”本质上就是让JS的属性查找机制自然地工作。如果你想明确地知道一个属性是从哪里来的，或者想遍历原型链来找到它，可以这样做：

function Animal(name) {
    this.name = name;
}

Animal.prototype.species = 'Unknown'; // 原型链上的“默认”属性
Animal.prototype.sound = function() {
    return 'Generic animal sound';
};

let dog = new Animal('Buddy');
dog.species = 'Canine'; // dog 自身有了 species 属性，覆盖了原型上的

let cat = new Animal('Whiskers');
// cat 自身没有 species 属性，会去原型链上找

console.log(dog.species); // 输出 'Canine' (dog自身的属性)
console.log(cat.species); // 输出 'Unknown' (从 Animal.prototype 获取)

// 如果你想明确地获取原型链上的那个“默认”值，你可以直接访问原型：
console.log(Object.getPrototypeOf(cat).species); // 输出 'Unknown'
console.log(Animal.prototype.species); // 输出 'Unknown'

// 甚至可以写一个函数来遍历查找：
function findPropertyInPrototypeChain(obj, propName) {
    let current = obj;
    while (current) {
        if (Object.prototype.hasOwnProperty.call(current, propName)) {
            // 找到了，返回当前对象和属性值
            return {
                owner: current,
                value: current[propName]
            };
        }
        current = Object.getPrototypeOf(current);
    }
    return null; // 没找到
}

console.log(findPropertyInPrototypeChain(dog, 'species')); // { owner: { name: 'Buddy', species: 'Canine' }, value: 'Canine' }
console.log(findPropertyInPrototypeChain(cat, 'species')); // { owner: Animal { species: 'Unknown', sound: [Function: sound] }, value: 'Unknown' }
console.log(findPropertyInPrototypeChain(cat, 'sound'));   // { owner: Animal { species: 'Unknown', sound: [Function: sound] }, value: [Function: sound] }
console.log(findPropertyInPrototypeChain(cat, 'nonExistent')); // null

这基本上就是JS处理“默认值”的方式。它不是一个主动的“获取”动作，更像是一个被动的“查找”过程。

如何判断一个属性是否来自原型链而非自身？

在JavaScript开发中，你经常会遇到需要区分一个属性是对象自身的（own property）还是从原型链上继承来的情况。这不仅仅是好奇心，很多时候它直接影响你的代码逻辑，比如遍历对象属性时。

最常用的方法是使用Object.prototype.hasOwnProperty()方法。这个方法会检查一个对象是否直接拥有某个属性，而不会去原型链上查找。

const myObject = {};
myObject.myOwnProperty = 'I am unique';

const protoObject = {
    inheritedProperty: 'I am inherited'
};

Object.setPrototypeOf(myObject, protoObject);

console.log(myObject.myOwnProperty);     // 'I am unique'
console.log(myObject.inheritedProperty); // 'I am inherited'

// 判断是否是自身属性
console.log(myObject.hasOwnProperty('myOwnProperty'));     // true
console.log(myObject.hasOwnProperty('inheritedProperty')); // false

// 另一个需要注意的运算符是 'in'
// 'in' 运算符会检查属性是否存在于对象本身或其原型链上
console.log('myOwnProperty' in myObject);     // true
console.log('inheritedProperty' in myObject); // true

// 甚至 'toString' 这种来自 Object.prototype 的属性也会被 'in' 找到
console.log('toString' in myObject);          // true
console.log(myObject.hasOwnProperty('toString')); // false

所以，如果你想确保只处理对象自身的属性，hasOwnProperty是你的首选。比如，在遍历对象的属性时，使用for...in循环结合hasOwnProperty是一个常见的模式，可以避免遍历到原型链上的属性：

for (const key in myObject) {
    if (myObject.hasOwnProperty(key)) {
        console.log(`Own property: ${key} = ${myObject[key]}`);
    }
}
// 输出: Own property: myOwnProperty = I am unique

这避免了不必要的副作用，也让你的代码更健壮。

修改原型链上的属性会带来哪些意想不到的问题？

修改原型链上的属性，尤其是那些会被多个实例共享的属性，常常会引发一些让人头疼的问题，我个人就踩过不少坑。它不像修改实例自身的属性那么直接，因为牵扯到“共享”这个概念。

一个最典型的例子就是共享引用类型数据：

function Configurator() {}

// 假设我们想给所有 Configurator 实例一个默认的设置对象
Configurator.prototype.defaultSettings = {
    theme: 'light',
    fontSize: 14
};

let user1Config = new Configurator();
let user2Config = new Configurator();

// user1 修改了设置
user1Config.defaultSettings.theme = 'dark';

console.log(user1Config.defaultSettings.theme); // 'dark'
console.log(user2Config.defaultSettings.theme); // 'dark' —— 糟糕！user2的设置也被改了

这里的问题在于defaultSettings是一个对象，它在原型上被所有实例共享。当你通过user1Config.defaultSettings去修改它时，实际上修改的是原型上的那个唯一对象，导致所有其他实例也看到了这个修改。如果defaultSettings是一个原始值（比如字符串或数字），就不会有这个问题，因为修改原始值会创建实例自己的副本（也就是“遮蔽”）。

另一个问题是“属性遮蔽”（Shadowing）。当你给一个实例添加一个与原型上同名的属性时，实例的属性会“遮蔽”原型上的属性。这听起来没什么，但如果后续你删除了实例的属性，那么原型上的属性又会“浮现”出来，这可能会导致一些难以追踪的bug：

function Item() {}
Item.prototype.status = 'available';

let item1 = new Item();
let item2 = new Item();

console.log(item1.status); // 'available'

item1.status = 'sold'; // 实例自身有了 status 属性，遮蔽了原型上的
console.log(item1.status); // 'sold'
console.log(item2.status); // 'available' (item2 依然使用原型上的)

delete item1.status; // 删除了 item1 自身的 status 属性
console.log(item1.status); // 'available' —— 原型上的又回来了

这种行为在复杂系统中可能会让开发者感到困惑，尤其是在没有明确区分自身属性和继承属性的情况下。

总的来说，修改原型链上的属性需要非常谨慎。对于引用类型数据，几乎总是建议在实例创建时就进行深拷贝或在构造函数中初始化，而不是依赖原型上的共享对象。而对于方法，原型是理想的放置位置，因为方法通常不改变自身状态。

在实际开发中，何时应该利用原型链的特性？

原型链在JavaScript中是实现继承和共享行为的核心机制，它的用处非常广泛，而且在很多场景下是性能和内存优化的关键。

最经典也是最直接的用例就是共享方法。如果你有成百上千个对象实例，每个实例都需要执行同样的方法（比如一个greet()方法），把这个方法放在原型上是最高效的方式。每个实例不会拥有自己的greet函数副本，它们都指向原型上的同一个函数。这不仅节省了内存，也保证了行为的一致性。

function User(name) {
    this.name = name;
}

// 将方法定义在原型上
User.prototype.sayHello = function() {
    console.log(`Hello, my name is ${this.name}`);
};

let userA = new User('Alice');
let userB = new User('Bob');

userA.sayHello(); // Hello, my name is Alice
userB.sayHello(); // Hello, my name is Bob

// 它们共享同一个函数引用
console.log(userA.sayHello === userB.sayHello); // true

这种模式是JavaScript面向对象编程的基石，也是ES6 class语法糖背后实际运行的机制。

另一个重要的应用是实现继承。通过原型链，一个对象可以继承另一个对象的属性和方法。这允许我们构建复杂的类型层次结构，实现代码复用。

// 假设我们有一个通用的 Animal 构造函数
function Animal(name) {
    this.name = name;
}
Animal.prototype.eat = function() {
    console.log(`${this.name} is eating.`);
};

// 现在我们想创建一个 Dog 类型，它继承 Animal 的特性
function Dog(name, breed) {
    Animal.call(this, name); // 调用父类构造函数，继承属性
    this.breed = breed;
}

// 关键一步：让 Dog 的原型继承 Animal 的原型
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog; // 修复 constructor 指向

// Dog 自己的方法
Dog.prototype.bark = function() {
    console.log(`${this.name} barks! Woof!`);
};

let myDog = new Dog('Max', 'Golden Retriever');
myDog.eat();  // Max is eating. (继承自 Animal.prototype)
myDog.bark(); // Max barks! Woof! (Dog.prototype 自己的方法)

通过Object.create()来设置原型，是实现这种继承的一种干净且推荐的方式。

此外，原型链也常用于添加默认配置或行为。比如，你有一个库或者框架，想要为用户提供一些默认的设置，但允许他们覆盖。你可以把这些默认设置放在原型上，用户在实例上设置同名属性就可以覆盖它。但正如前面提到的，对于可变对象，需要非常小心。

最后，Polyfills（垫片）也经常利用原型链来为旧的JavaScript环境添加新的API。例如，如果旧浏览器不支持Array.prototype.includes，你可以手动在Array.prototype上添加这个方法。但这通常不推荐在生产环境中随意修改内置对象的原型，因为它可能导致冲突和不可预测的行为。

总结一下，原型链是JavaScript的灵魂之一，理解并合理利用它，能让你写出更高效、更结构化的代码。核心思想就是：共享不变的、通用的行为和属性，让每个实例只拥有它自己独有的数据。

终于介绍完啦！小伙伴们，这篇关于《JS原型链默认值获取方法》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！