检测javascript对象的原型类型没有统一方法，需根据场景选择：1. 使用object.prototype.tostring.call()可精准识别内置类型（如数组、日期等），返回[object type]格式字符串，不受constructor篡改影响；2. instanceof操作符用于检查对象是否为某构造函数实例，适用于自定义类和继承关系判断，但跨iframe时可能失效；3. constructor属性可直观判断创建对象的构造函数，但易被修改导致结果不可靠；4. typeof对对象类型区分能力弱，除函数外所有对象均返回”object”，无法精确识别具体类型；5. 对于数组应优先使用array.isarray()，其他内置类型推荐object.prototype.tostring.call()，自定义类型则使用instanceof进行原型链检测，constructor和object.getprototypeof()可作为辅助工具用于理解和验证原型结构，最终方法选择取决于具体需求和准确性要求。
在JavaScript里，要检测一个对象的原型类型，其实并没有一个放之四海而皆准的“银弹”。我们通常会根据具体需求和对象的特性，选择
Object.prototype.toString.call()
、
instanceof
操作符，或者直接检查
constructor
属性。每种方法都有它的适用场景和局限性，理解它们背后的原理，才能做出最准确的判断。
解决方案
当我们谈论检测JavaScript对象的原型类型时，实际上是在尝试弄清楚一个对象究竟是“什么”。这有点像给一个陌生人做身份识别，你需要不同的工具来确认Ta是做什么的、来自哪里。
最稳妥的办法之一，我个人觉得，是利用
Object.prototype.toString.call()
。这个方法非常强大，因为它返回的是一个表示对象类型的字符串，格式通常是
[object Type]
。它能准确识别几乎所有内置对象类型，比如数组、日期、正则表达式，甚至是函数。举个例子，
Object.prototype.toString.call([])
会返回
"[object Array]"
，而
Object.prototype.toString.call({})
则是
"[object Object]"
。它的好处在于，即使对象的
constructor
属性被篡改了，它依然能给出正确的内置类型。
然后是
instanceof
操作符。这个家伙主要用来检查一个对象是否是某个构造函数（或类）的实例。它的工作原理是沿着原型链向上查找，看构造函数的
prototype
属性是否存在于对象的原型链上。比如，
[1, 2, 3] instanceof Array
会返回
true
，因为数组的原型链上确实有
Array.prototype
。对于自定义的类或构造函数，
instanceof
就显得尤为好用。但它也有个小问题，就是跨iframe或不同Realm的对象，即使它们看起来一样，
instanceof
也可能因为原型链不在同一个上下文而失效。
最后，我们可以看看对象的
constructor
属性。每个对象通常都会有一个
constructor
属性指向创建它的构造函数。比如，
[].constructor === Array
会返回
true
。这个方法直观易懂，但它的缺点也很明显：
constructor
属性是可以被修改的。如果有人不小心或者故意改了它，那么这个检测结果就不可靠了。所以，用它的时候得留个心眼。
为什么
typeof
在检测对象原型时常常不够用？
说实话，每次遇到这个问题，我都会先想到
typeof
，但很快就会意识到它的局限性。
typeof
对于基本数据类型（如
string
,
number
,
boolean
,
symbol
,
bigint
,
undefined
）和函数（
function
）来说，是相当准确和直接的。但一旦涉及到对象，它就显得力不从心了。你会发现，无论是数组、日期、正则表达式，甚至是
null
，
typeof
的结果都是
"object"
。
这就像你问一个人“你是人类吗？”，他回答“我是生物”。没错，他是生物，但你无法通过这个答案知道他具体是哪种生物，是人、狗还是猫。
typeof
就是这样，它告诉你这是一个“对象”，但无法深入到具体的原型类型。所以，如果你想区分一个普通对象和一个数组，或者一个日期对象，
typeof
是帮不上忙的，它只会告诉你它们都是“对象”。这就是为什么我们需要更精细的工具，比如
Object.prototype.toString.call()
，来做更细致的分类。
如何区分数组和普通对象，以及其他内置类型？
要精准区分这些内置类型，我个人最推荐的还是
Object.prototype.toString.call()
。它就像一个专业的DNA检测工具，能准确识别出对象的“物种”。
比如，你想知道一个变量是不是数组，你可以这么做：
function isArray(value) {
return Object.prototype.toString.call(value) === '[object Array]';
}
console.log(isArray([])); // true
console.log(isArray({})); // false
console.log(isArray(new Date())); // false
同理，要区分日期对象：
function isDate(value) {
return Object.prototype.toString.call(value) === '[object Date]';
}
console.log(isDate(new Date())); // true
console.log(isDate({})); // false
对于函数、正则表达式、错误对象等，原理都是一样的：
console.log(Object.prototype.toString.call(function(){})); // "[object Function]"
console.log(Object.prototype.toString.call(/abc/)); // "[object RegExp]"
console.log(Object.prototype.toString.call(new Error())); // "[object Error]"
console.log(Object.prototype.toString.call(Math)); // "[object Math]"
console.log(Object.prototype.toString.call(JSON)); // "[object JSON]"
当然，对于数组，还有一个更简洁、更现代的方法，就是
Array.isArray()
。这个方法是ES5引入的，专门用来判断一个值是不是数组，它比
Object.prototype.toString.call()
更直观，也更推荐使用，如果你的目标只是判断数组的话。
console.log(Array.isArray([])); // true
console.log(Array.isArray({})); // false
但请记住，
Array.isArray()
是特例，对于其他内置类型，
Object.prototype.toString.call()
依然是你的首选。
自定义对象或类的原型链检测有何特殊之处？
当我们跳出JavaScript内置类型，开始处理自己定义的类或构造函数时，情况就变得有点意思了。这时候，
instanceof
操作符就成了我们的主力军。它不像
Object.prototype.toString.call()
那样只关心内置类型，
instanceof
更关注一个对象是否“继承”自某个特定的构造函数或类。
想象一下你定义了一个
Person
类：
class Person {
constructor(name) {
this.name = name;
}
}
const alice = new Person('Alice');
const bob = { name: 'Bob' }; // 普通对象
这时候，如果你想知道
alice
是不是一个
Person
的实例，
instanceof
就能派上用场：
console.log(alice instanceof Person); // true console.log(bob instanceof Person); // false console.log(alice instanceof Object); // true (因为所有对象都继承自Object)
instanceof
会沿着
alice
的原型链向上查找，直到找到
Person.prototype
为止。如果找到了，就返回
true
。它能很好地处理继承关系，比如如果有一个
Student
类继承自
Person
，那么
new Student() instanceof Person
也会是
true
。
至于
constructor
属性，它在这里也能用，但就像前面说的，它不太可靠。
console.log(alice.constructor === Person); // true console.log(bob.constructor === Object); // true
但如果有人做了这样的操作：
function MyObject() {}
const obj = new MyObject();
obj.constructor = Array; // 故意修改constructor
console.log(obj.constructor === MyObject); // false
console.log(obj.constructor === Array); // true (但obj并不是数组)
你看，
constructor
属性很容易被误导。所以，除非你对对象的来源和其
constructor
属性的完整性有绝对的把握，否则在检测自定义类型时，我还是更倾向于使用
instanceof
。
另外，如果你只是想获取一个对象的直接原型，而不是判断其类型或继承关系，
Object.getPrototypeOf()
也是一个很有用的方法。它直接返回指定对象的原型。
const obj = {};
const arr = [];
console.log(Object.getPrototypeOf(obj) === Object.prototype); // true
console.log(Object.getPrototypeOf(arr) === Array.prototype); // true
console.log(Object.getPrototypeOf(alice) === Person.prototype); // true
这对于理解原型链的结构非常有帮助，但在直接判断“类型”时，它通常作为辅助手段。
总的来说，选择哪种方法，取决于你的具体场景和对准确性的要求。内置类型用
Object.prototype.toString.call()
（数组有
Array.isArray()
），自定义类型用
instanceof
，而
constructor
和
Object.getPrototypeOf()
则作为辅助和理解原型链的工具。
暂无评论内容