如何判断JS对象原型是否被隐藏

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个文章开发实战，手把手教大家学习《如何判断JS对象原型是否被隐藏》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

要判断一个对象是否没有原型或原型属性是否不可枚举，1. 使用 Object.getPrototypeOf(obj) === null 判断对象是否无原型，若为 true 则该对象没有原型；2. 使用 Object.getOwnPropertyDescriptor() 沿原型链检查属性的 enumerable 属性，若为 false 则该属性不可枚举，即“隐藏”于常规遍历之外；3. 避免使用非标准的 proto 属性，因其可被篡改，应优先使用标准方法 Object.getPrototypeOf() 和 Object.getOwnPropertyNames() 等进行可靠检测，从而准确掌握原型链的真实状态。

在JavaScript里，要判断一个对象的原型是否“被隐藏”，这个说法听起来有点玄乎，因为原型链本身是语言的核心机制，它并不会真的“隐藏”起来。更准确地说，我们通常想知道的是：这个对象到底有没有原型？它的原型链是不是我们预期的那样？或者，原型上的某些属性是不是不那么容易被发现（比如，不被常规的枚举方法列出来）？核心思想是，原型链是开放的，我们有标准的方法去探究它。

要探究一个对象的原型状态，最直接、最靠谱的办法就是使用 Object.getPrototypeOf()。这个方法会返回你传入的那个对象的直接原型。如果它返回 null，那就说明这个对象是原型链的顶端，它自己没有再往上的原型了，就像我们用 Object.create(null) 创建的那些“纯粹”的对象。

但如果你说的“隐藏”是指原型上的某些属性，它们虽然存在，但却不被 for...in 循环或者 Object.keys() 这样的方法枚举出来，那这通常是由于这些属性的 enumerable 描述符被设置成了 false。这种情况在很多内置对象和库的实现里都很常见，比如 Array.prototype.forEach 这样的方法，它们确实存在，但你不会在遍历数组实例时看到它们。要检查这类属性，你需要更深入地使用 Object.getOwnPropertyDescriptor() 来查看属性的详细配置，或者直接用 Object.getOwnPropertyNames() 和 Object.getOwnPropertySymbols() 来获取所有（包括不可枚举的）自身属性。

const myObj = {};
Object.defineProperty(myObj, 'hiddenProp', {
  value: 'I am hidden from enumeration',
  enumerable: false, // 关键在这里
});

console.log(Object.keys(myObj)); // []
console.log(Object.getOwnPropertyNames(myObj)); // ["hiddenProp"]

// 如果是原型上的属性
const proto = {
  visibleProtoProp: 1,
};
Object.defineProperty(proto, 'hiddenProtoProp', {
  value: 2,
  enumerable: false,
});

const instance = Object.create(proto);
console.log(instance.visibleProtoProp); // 1
console.log(instance.hiddenProtoProp); // 2

// 遍历实例，看不到原型上的不可枚举属性
for (let key in instance) {
  // 只会输出 visibleProtoProp，因为 hiddenProtoProp 不可枚举
  console.log(key);
}

如何判断一个对象是否根本没有原型？

有时候，我们确实需要一个“干净”的对象，它不继承任何东西，甚至连 Object.prototype 上的那些常用方法（比如 toString、hasOwnProperty）都没有。这种情况下，我们通常会用 Object.create(null) 来创建这样的对象。判断起来也很简单直接：

Object.getPrototypeOf(yourObject) === null

如果这个表达式的结果是 true，那么恭喜你，你手里的就是一个“原型链终结者”。我个人在做一些纯粹的哈希映射或者需要避免原型链上潜在冲突时，就特别喜欢用这种方式。它能确保你访问的属性就是你直接定义在对象上的，不会意外地“撞”到原型链上的同名属性。这在构建一些数据结构时，能带来意想不到的简洁和安全性。

如何检查原型链上特定属性的可见性（可枚举性）？

这是“隐藏”概念里最常见的一种情况了。一个属性即便存在于原型上，如果它的 enumerable 标志位是 false，那么它就不会在你用 for...in 循环或者 Object.keys() 获取属性时出现。这就像是给属性贴了个“请勿打扰”的标签，它在那里，但不是为了被随意“展示”的。

要检查一个特定属性是否可枚举，可以这样做：

1. 确定属性是否存在： 先用 in 操作符检查属性是否存在于对象或其原型链上。
2. 获取属性描述符： 使用 Object.getOwnPropertyDescriptor(obj, propName) 获取该属性的描述符。注意，这个方法只检查对象自身的属性。如果属性在原型链上，你需要沿着原型链向上查找。
3. 检查 enumerable 标志： 在获取到的描述符中，查看 enumerable 属性的值。

举个例子，我们都知道 Array.prototype 上有很多方法，比如 forEach。它们是不可枚举的：

console.log(Object.getOwnPropertyDescriptor(Array.prototype, 'forEach').enumerable); // false
const arr = [];
for (let key in arr) {
  console.log(key); // 什么都不会输出，因为 forEach 不可枚举
}

在我看来，这种设计非常合理。想象一下，如果 forEach 这样的方法是可枚举的，那么当你遍历一个数组时，你会看到 0, 1, 2, forEach, map, filter...，这显然不是我们想要的行为。这种“隐藏”是刻意的，是为了保持数据属性和方法属性的界限清晰，让迭代操作更专注于数据本身。

__proto__ 属性的可靠性与潜在陷阱

你可能在一些老代码或者教程里看到过 __proto__ 这个属性，它看起来可以直接访问或设置一个对象的原型。是的，它确实可以做到，但它并不是一个标准的、推荐的用法。__proto__ 实际上是一个非标准的访问器属性，它在大多数现代JavaScript环境中都得到了实现，但它存在一些潜在的问题，尤其是在判断原型“隐藏”这种语境下。

最大的问题在于，__proto__ 作为一个普通的属性，它本身是可以被修改、甚至被删除的。这意味着，如果你依赖 obj.__proto__ 来判断原型，而这个 __proto__ 属性恰好被某个恶意代码或者不规范的库给篡改了，那么你得到的结果就会是错误的，甚至会抛出错误。

const obj = {};
console.log(obj.__proto__ === Object.prototype); // true (通常情况下)

// 篡改 __proto__
Object.defineProperty(obj, '__proto__', {
  get() {
    console.log('__proto__ 被访问了！');
    return null; // 假装没有原型
  },
  set() {
    console.log('__proto__ 被设置了！');
  },
  configurable: true // 允许重新配置或删除
});

console.log(obj.__proto__); // __proto__ 被访问了！ null
console.log(Object.getPrototypeOf(obj)); // [Object: null prototype] {} (依然是 Object.prototype)

看到没？obj.__proto__ 返回了 null，但 Object.getPrototypeOf(obj) 依然返回了正确的原型。这清楚地表明，Object.getPrototypeOf() 才是那个值得信赖的“原型侦探”。所以，我强烈建议，无论何时需要检查或操作对象的原型，都应该坚持使用 Object.getPrototypeOf() 和 Object.setPrototypeOf() 这些标准API，它们提供了更稳定、更可预测的行为，能有效避免那些由 __proto__ 带来的意料之外的“隐藏”或误导。

今天关于《如何判断JS对象原型是否被隐藏》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！