最直接获取对象构造函数的方式是使用obj.constructor属性，它指向创建该对象的构造函数；2. 由于constructor属性可被修改且在原型链重写时可能丢失，因此不总是可靠；3. 更准确的类型判断方法包括：instanceof用于检测对象是否为某构造函数实例；object.prototype.tostring.call()能精准识别内置类型并避免跨realm问题；typeof适用于原始类型和函数判断；4. 实际应用中应根据场景选择：typeof处理原始类型，object.prototype.tostring.call()判断内置对象类型，instanceof检查自定义类实例，constructor仅在可控环境下使用。应综合运用这些方法以确保类型判断的准确性与代码的健壮性。
JavaScript中获取对象的构造函数，最直接且最常见的方式就是通过对象的constructor属性。这个属性通常指向创建该实例的构造函数本身。
解决方案
在JavaScript里，每个对象（除了少数特例，比如Object.create(null)创建的对象）都有一个内部的链接指向它的原型对象（prototype）。而这个原型对象上，又通常会有一个constructor属性，指向其构造函数。所以，当你通过obj.constructor去访问时，实际上是沿着原型链向上查找，直到找到这个constructor属性。
举几个例子你就明白了：
// 1. 基本对象和数组let obj = {};console.log(obj.constructor === Object); // truelet arr = [];console.log(arr.constructor === Array); // truelet str = "hello";console.log(str.constructor === String); // true (这里是原始值包装对象，而不是原始值本身)// 2. 函数function MyFunction() {}console.log(MyFunction.constructor === Function); // true (函数也是Function的实例)// 3. 自定义类或构造函数function Person(name) { this.name = name;}let p = new Person('张三');console.log(p.constructor === Person); // trueclass Animal { constructor(type) { this.type = type; }}let dog = new Animal('狗');console.log(dog.constructor === Animal); // true
除了直接访问obj.constructor，你也可以通过Object.getPrototypeOf(obj).constructor来获取。这两种方式在大多数情况下是等价的，因为obj.constructor本身就是沿着原型链查找的结果。不过，后面这种方式在某些场景下可能更清晰，因为它明确了你是从原型链上获取的构造函数。
let myObj = {};console.log(Object.getPrototypeOf(myObj).constructor === Object); // true
为什么constructor属性有时候会“失效”或不那么可靠？
说实话，constructor属性虽然直接，但在实际使用中，它确实有一些“坑”，导致它不总是那么可靠。这主要是因为它是一个可写的属性，并且在原型链继承中，它的指向可能会变得不那么直观。
一个常见的问题是，当你重写一个构造函数的prototype时，如果没有显式地把constructor指回去，那么它就会丢失原来的指向。比如：
function Fruit() {}Fruit.prototype.getTaste = function() { /* ... */ }; // 此时Fruit.prototype.constructor 还是 Fruitfunction Apple() {}// 错误的做法：直接赋值新的原型对象，会覆盖掉原型的constructor属性Apple.prototype = { variety: 'Fuji', getTaste: function() { return 'sweet'; }};let myApple = new Apple();console.log(myApple.constructor === Apple); // false!console.log(myApple.constructor === Object); // true! 为什么？因为Apple.prototype现在指向了一个新的对象字面量，而这个字面量的constructor默认是Object。// 正确的做法：在重写原型时，手动修复constructor指向function Orange() {}Orange.prototype = { constructor: Orange, // 手动指回Orange color: 'orange', getTaste: function() { return 'sour'; }};let myOrange = new Orange();console.log(myOrange.constructor === Orange); // true
这种“意外”的constructor指向，在继承链上尤为明显。子类的实例，如果子类没有正确设置自己的prototype.constructor，那么它的constructor可能会指向父类，甚至更上层的Object。
另外，Object.create(null)创建的对象，因为它没有原型链，所以也就没有constructor属性：
let emptyObj = Object.create(null);console.log(emptyObj.constructor); // undefined
所以，依赖constructor属性来判断一个对象的精确类型或来源时，你需要对它的上下文和原型链有足够的了解，否则可能会得到意想不到的结果。
除了constructor，还有哪些方法可以更“准确”地判断对象的类型或来源？
当constructor属性不够可靠时，JavaScript提供了其他一些方法来帮助我们判断对象的类型，它们各自有不同的适用场景和优缺点。
1. instanceof操作符
instanceof用于检测一个对象是否是某个构造函数的实例，或者说，它的原型链上是否存在某个构造函数的prototype。
function Vehicle() {}function Car() {}Car.prototype = Object.create(Vehicle.prototype); // 继承Vehiclelet myCar = new Car();console.log(myCar instanceof Car); // trueconsole.log(myCar instanceof Vehicle); // trueconsole.log(myCar instanceof Object); // trueconsole.log(myCar instanceof Array); // false
instanceof的优点是语义清晰，直观地表达了“是不是某个类的实例”。但它的局限性在于：
它只能判断对象是否是某个构造函数的实例，不能判断原始值（如字符串、数字、布尔值）。它在跨iframe或跨realm（不同的JavaScript执行环境）时会失效，因为每个realm都有自己独立的全局对象和构造函数。例如，一个iframe中的Array与另一个iframe中的Array是不同的对象。
2. Object.prototype.toString.call()
这是在JavaScript中判断内置类型最“万能”且最可靠的方法。它通过访问对象的内部[[Class]]属性（在ES6+中，这更多地被描述为Symbol.toStringTag），返回一个格式为[object Type]的字符串。
console.log(Object.prototype.toString.call({})); // "[object Object]"console.log(Object.prototype.toString.call([])); // "[object Array]"console.log(Object.prototype.toString.call(function(){})); // "[object Function]"console.log(Object.prototype.toString.call(new Date()));// "[object Date]"console.log(Object.prototype.toString.call(null)); // "[object Null]"console.log(Object.prototype.toString.call(undefined)); // "[object Undefined]"console.log(Object.prototype.toString.call(123)); // "[object Number]"console.log(Object.prototype.toString.call("hello")); // "[object String]"console.log(Object.prototype.toString.call(true)); // "[object Boolean]"console.log(Object.prototype.toString.call(Math)); // "[object Math]"console.log(Object.prototype.toString.call(JSON)); // "[object JSON]"
这个方法的强大之处在于，它不受constructor属性被篡改的影响，也不受跨realm问题的影响（对于内置类型）。对于自定义对象，如果你设置了Symbol.toStringTag，它也会反映出来：
class MyCustomClass { get [Symbol.toStringTag]() { return 'MyCustomType'; }}let instance = new MyCustomClass();console.log(Object.prototype.toString.call(instance)); // "[object MyCustomType]"
3. typeof操作符
typeof主要用于判断原始数据类型和函数。
console.log(typeof "hello"); // "string"console.log(typeof 123); // "number"console.log(typeof true); // "boolean"console.log(typeof undefined); // "undefined"console.log(typeof Symbol()); // "symbol"console.log(typeof 10n); // "bigint"console.log(typeof function(){}); // "function"console.log(typeof {}); // "object" (注意：null也是"object")console.log(typeof null); // "object" (这是JavaScript历史遗留问题)
typeof对于判断对象类型非常有限，因为它会将所有非函数对象都返回"object"，包括数组、日期、正则等。
在实际开发中，获取构造函数或判断类型，我应该如何选择最合适的方法？
选择哪种方法，真的取决于你具体要解决什么问题，以及你对所处理对象的“信任度”。没有一个银弹，只有最适合当前场景的工具。
1. 当你需要知道一个对象是否是某个特定类的实例，并且你确定该类定义在当前执行环境中时，instanceof是首选。比如，在一个组件库中，你可能需要检查传入的props是否是某个自定义组件类的实例，或者一个事件对象是否是MouseEvent。它的可读性很好，意图明确。
function processEvent(event) { if (event instanceof MouseEvent) { console.log("这是一个鼠标事件"); // ...处理鼠标事件特有逻辑 } else if (event instanceof KeyboardEvent) { console.log("这是一个键盘事件"); // ...处理键盘事件特有逻辑 }}
2. 当你需要精确判断一个内置对象的类型（如数组、日期、正则表达式等），或者处理来自不同JavaScript环境的对象时，Object.prototype.toString.call()是你的最佳伙伴。这是判断数组最推荐的方式：Array.isArray()，其内部就是基于Object.prototype.toString.call()实现的。当你不确定一个变量是不是一个纯粹的对象字面量时，它也很有用：
function isPlainObject(obj) { return Object.prototype.toString.call(obj) === '[object Object]';}console.log(isPlainObject({})); // trueconsole.log(isPlainObject([])); // falseconsole.log(isPlainObject(new Date())); // false
3. 对于原始数据类型和函数，typeof是最直接、性能最好的选择。它简单明了，没有副作用。
function safelyProcess(value) { if (typeof value === 'string') { return value.trim(); } if (typeof value === 'number') { return value * 2; } if (typeof value === 'function') { return value(); } // ...}
4. constructor属性，在你自己完全控制对象创建和原型链的情况下，或者仅仅是想快速获取一个对象的“名义”构造函数时，可以用。但一旦涉及到继承、第三方库、或者你无法保证prototype.constructor没有被篡改的场景，就应该警惕并考虑其他更稳健的方法。比如，如果你正在写一个简单的序列化工具，并且你知道所有待序列化的对象都是你自己的类实例，且你确保了constructor的正确性，那么obj.constructor.name或许可以帮助你重建对象。
总结一下，我的建议是：
判断原始类型和函数： 用 typeof。判断内置对象类型（如Array, Date, RegExp等），或需要跨realm兼容： 用 Object.prototype.toString.call()。判断自定义类的实例，且在同一realm内： 用 instanceof。获取构造函数本身（而非类型字符串），且确保constructor属性未被篡改： 用 obj.constructor 或 Object.getPrototypeOf(obj).constructor。
理解这些方法的优缺点和适用场景，能让你在编写健壮的JavaScript代码时游刃有余。别盲目地只用一种，灵活组合才是王道。
以上就是js如何获取对象的构造函数的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1512975.html
微信扫一扫 
支付宝扫一扫 
