js怎么判断属性是否在原型链末端-js教程-PHP中文网

要判断属性是否在原型链末端，首先需明确“末端”通常指object.prototype；2. 使用findpropertydefiner函数沿原型链查找属性首次定义的位置；3. 若该属性定义者为object.prototype，则可视为在原型链末端；4. 对于object.create(null)等无继承的对象，其自身属性即位于末端；5. 特定类型对象的末端可能是其类型原型如array.prototype。因此，通过追溯属性定义者并比对是否为特定原型对象，可准确判断其是否位于原型链末端。

js怎么判断属性是否在原型链末端

js怎么判断属性是否在原型链末端？

在我看来，要判断一个属性是否“在原型链末端”，我们首先得明确“末端”指的是什么。对于绝大多数JavaScript对象而言，原型链的终点往往是

Object.prototype

登录后复制

，再往上就是

null

登录后复制

了。所以，这个问题更贴切的理解是：一个属性是不是直接定义在

Object.prototype

登录后复制

上，或者说，当你从一个对象上访问某个属性时，它的“根源”是不是追溯到了

Object.prototype

登录后复制

，而没有被更靠近实例的对象所覆盖。这可不是一个简单的“是”或“否”能概括的，它牵扯到JavaScript深层次的原型查找机制。

解决方案

要真正找出属性在原型链上“出生”的位置，我们通常需要沿着原型链向上追溯，直到找到那个真正拥有该属性（作为自身属性）的对象。

这里有一个函数，可以帮助我们找到一个属性在原型链上首次被定义（作为自身属性）的对象：

/**
 * 查找属性在原型链上的实际定义者
 * @param {object} obj - 要检查的对象
 * @param {string} prop - 属性名
 * @returns {object|null} 返回定义该属性的对象，如果属性不存在则返回null
 */
function findPropertyDefiner(obj, prop) {
  // 处理null或非对象的情况，避免TypeError
  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
    return null;
  }

  let current = obj;
  // 沿着原型链向上查找
  while (current) {
    // 使用Object.prototype.hasOwnProperty.call确保正确性，避免hasOwnProperty被覆盖
    if (Object.prototype.hasOwnProperty.call(current, prop)) {
      return current; // 找到属性的实际定义者
    }
    // 获取当前对象的原型
    current = Object.getPrototypeOf(current);
  }
  return null; // 属性在整个原型链上都未找到
}

// 示例：
const myProto = {
  protoProp: '我是原型上的属性',
  sharedMethod: function() { console.log('来自原型的方法'); }
};

const myObj = Object.create(myProto);
myObj.ownProp = '我是实例自身的属性';
myObj.sharedMethod = function() { console.log('实例覆盖了原型的方法'); }; // 覆盖

console.log('--- 属性定义者查找 ---');
console.log(`'ownProp' 定义在: ${findPropertyDefiner(myObj, 'ownProp') === myObj ? 'myObj' : '其他地方'}`); // myObj
console.log(`'protoProp' 定义在: ${findPropertyDefiner(myObj, 'protoProp') === myProto ? 'myProto' : '其他地方'}`); // myProto
console.log(`'toString' 定义在: ${findPropertyDefiner(myObj, 'toString') === Object.prototype ? 'Object.prototype' : '其他地方'}`); // Object.prototype
console.log(`'sharedMethod' 定义在: ${findPropertyDefiner(myObj, 'sharedMethod') === myObj ? 'myObj' : '其他地方'}`); // myObj (因为被覆盖了)
console.log(`'nonExistent' 定义在: ${findPropertyDefiner(myObj, 'nonExistent') === null ? '未找到' : '其他地方'}`); // 未找到

// 那么，如何判断属性是否在“原型链末端”？
// 如果我们认为“末端”就是Object.prototype，那么：
const toStringDefiner = findPropertyDefiner(myObj, 'toString');
if (toStringDefiner === Object.prototype) {
  console.log(`'toString' 确实定义在 Object.prototype 上，可以视为“末端”属性。`);
}

const myProtoPropDefiner = findPropertyDefiner(myObj, 'protoProp');
if (myProtoPropDefiner === Object.prototype) {
  console.log(`'protoProp' 定义在 Object.prototype 上。`); // 不会执行，因为定义在myProto
} else if (myProtoPropDefiner !== null) {
  console.log(`'protoProp' 定义在原型链上，但不是 Object.prototype。`);
}

登录后复制

这段代码的核心思想就是：不断地获取当前对象的原型，然后用

hasOwnProperty

登录后复制

去检查当前原型对象是否拥有这个属性。一旦找到了，那个对象就是属性的真正定义者。如果一直找到

null

登录后复制

还没找到，那说明这个属性压根就不存在于这条原型链上。

为什么理解属性的“根源”如此重要？

搞清楚一个属性究竟是实例自身的，还是从原型链上继承来的，甚至具体继承自哪个原型对象，这在JavaScript开发中简直是家常便饭，而且非常关键。

首先，它能帮你避免一些隐蔽的bug。比如，你可能想给一个对象添加一个新属性，结果不小心覆盖（shadow）了原型上的同名属性，或者更糟的是，你以为修改的是实例属性，结果改动了共享的原型属性，影响了所有继承自它的对象。

hasOwnProperty

登录后复制

的存在就是为了解决这个问题，它能明确告诉你一个属性是不是对象“自己”的。

盘古大模型

华为云推出的一系列高性能人工智能大模型

查看详情

其次，性能考量。虽然现代JS引擎对属性查找做了大量优化，但理解查找路径仍然有助于我们写出更高效的代码。尤其是在涉及到大量对象和频繁属性访问的场景下，如果能避免不必要的原型链查找，哪怕是微小的优化，累积起来也可能带来性能提升。

再者，是代码的健壮性与可维护性。当你在处理来自外部或不确定来源的对象时，了解属性的来源能让你更好地预测其行为。比如，你拿到一个对象，想遍历它的所有“自有”属性，这时候就必须配合

hasOwnProperty

登录后复制

来过滤，否则

for...in

登录后复制

循环会把原型链上的可枚举属性也一并列出来，这往往不是你想要的。

最后，在设计复杂的面向对象结构或者框架时，对原型链和属性查找机制的深刻理解是基石。它让你能更灵活地利用原型继承的强大能力，实现代码复用、多态等高级特性。

深入理解原型链与属性查找机制

要真正理解上面那个

findPropertyDefiner

登录后复制

函数的工作原理，我们得稍微深入一下JavaScript的内部。每个JavaScript对象都有一个内部的

[[Prototype]]

登录后复制

属性（在ES5之前通常通过

__proto__

登录后复制

访问，现在更推荐使用

Object.getPrototypeOf()

登录后复制

和

Object.setPrototypeOf()

登录后复制

）。这个

[[Prototype]]

登录后复制

指向的就是它的原型对象。当你在一个对象上尝试访问一个属性时，JavaScript引擎会遵循一套严格的查找规则：

首先检查对象自身：引擎会先看这个属性是不是对象的“自有属性”（own property），也就是直接定义在这个对象上的属性。如果找到了，查找过程就结束了，并返回这个属性的值。
沿着原型链向上查找：如果对象自身没有这个属性，引擎就会沿着
```
[[Prototype]]
```
登录后复制
链接，去它的原型对象上查找。如果原型对象有这个属性，就返回。
重复此过程：如果原型对象也没有，就继续沿着原型的原型查找，直到找到这个属性。
到达
null
登录后复制
：如果一直查到原型链的顶端——也就是
```
Object.prototype
```
登录后复制
的原型
```
null
```
登录后复制
——仍然没有找到这个属性，那么查找就结束了，结果就是
```
undefined
```
登录后复制
。

这个过程，就是我们常说的“原型链查找”或“属性查找”。它是一个单向的过程，只向上，不会向下。这也是为什么当你修改一个继承来的属性时，如果你不是在它原始定义的位置上修改，而是在实例上赋值，那么实际上你是在实例上创建了一个新的同名属性，覆盖（shadowing）了原型上的那个。

除了

Object.prototype

登录后复制

，还有哪些“原型链末端”的考量？

当我们谈论“原型链末端”时，

Object.prototype

登录后复制

确实是大多数情况下我们默认的“公共终点”。但从更广义的角度来看，还有一些情况值得我们思考：

绝对的末端：
```
null
```
登录后复制
在JavaScript中，
```
null
```
登录后复制
是原型链的绝对末端。
```
Object.getPrototypeOf(Object.prototype)
```
登录后复制
的结果就是
```
null
```
登录后复制
。这意味着任何属性查找，如果一直到
```
Object.prototype
```
登录后复制
都没有找到，那么它就会尝试在
```
null
```
登录后复制
上查找，但显然这不可能成功，最终结果就是
```
undefined
```
登录后复制
。从这个意义上说，
```
null
```
登录后复制
才是原型链的“物理末端”。
自定义的“末端” 我们并非总是需要
```
Object.prototype
```
登录后复制
作为原型链的终点。例如，通过
```
Object.create(null)
```
登录后复制
创建的对象，它的原型就是
```
null
```
登录后复制
。这样的对象没有继承任何来自
```
Object.prototype
```
登录后复制
的属性和方法（比如
```
toString
```
登录后复制
、
```
hasOwnProperty
```
登录后复制
等）。在这些对象上，如果一个属性是自身的，那它就是“末端”了，因为它的原型链非常短，直接就是
```
null
```
登录后复制
。这在一些场景下非常有用，比如当你需要一个纯粹的字典，不希望有任何继承来的属性干扰时。
```
const pureDict = Object.create(null);
pureDict.name = 'Pure Object';
console.log(findPropertyDefiner(pureDict, 'name') === pureDict); // true
console.log(findPropertyDefiner(pureDict, 'toString') === null); // true，因为没有继承
```
登录后复制
特定类型对象的“末端” 对于像数组、函数、正则表达式等内置对象，它们的原型链在到达
```
Object.prototype
```
登录后复制
之前，通常还会经过它们各自特定的原型对象，例如
```
Array.prototype
```
登录后复制
、
```
Function.prototype
```
登录后复制
、
```
RegExp.prototype
```
登录后复制
。对这些特定类型的对象来说，它们各自的原型对象可以看作是它们特定功能集的“末端”。比如，一个数组的
```
push
```
登录后复制
方法就定义在
```
Array.prototype
```
登录后复制
上，对于一个普通的数组实例而言，
```
Array.prototype
```
登录后复制
就是
```
push
```
登录后复制
这个方法在原型链上的“末端”定义者。
```
const myArray = [];
console.log(findPropertyDefiner(myArray, 'push') === Array.prototype); // true
console.log(findPropertyDefiner(myArray, 'toString') === Object.prototype); // true
```
登录后复制