要判断一个对象是否没有原型或原型属性是否不可枚举，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()获取属性时出现。这就像是给属性贴了个“请勿打扰”的标签，它在那里，但不是为了被随意“展示”的。
要检查一个特定属性是否可枚举，可以这样做：
-
确定属性是否存在： 先用
in
操作符检查属性是否存在于对象或其原型链上。 -
获取属性描述符： 使用
Object.getOwnPropertyDescriptor(obj, propName)
获取该属性的描述符。注意，这个方法只检查对象自身的属性。如果属性在原型链上，你需要沿着原型链向上查找。 -
检查
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__带来的意料之外的“隐藏”或误导。
