JS判断对象原型类型的方法有哪些

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《JS如何判断对象原型类型》，以下内容主要包含等知识点，如果你正在学习或准备学习文章，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

检测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()则作为辅助和理解原型链的工具。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。