最准确的判断方式是在构造函数内部使用 new.target，若函数通过 new 调用则 new.target 指向构造函数，否则为 undefined；2. 对于已创建的对象，可使用 instanceof 判断其原型链是否包含构造函数的 prototype，但该方法在跨 realm 或原型链被修改时会失效；3. 可通过 Object.getprototypeof() 或 isprototypeof() 更精确地检查原型链关系；4. constructor 属性不可靠，因其可被修改；5. 可在构造函数中添加自定义标记（如 this._isnewinstance = true）来实现可靠的“事后”判断，前提是能控制构造逻辑。最终，最推荐的方案是在构造时用 new.target 控制行为，外部判断则结合 instanceof 与原型检查并注意其局限性。
在JavaScript里，要百分之百地“事后”判断一个对象是不是通过
new
关键字创建的，这事儿有点微妙，甚至可以说，没有一个完美的银弹。最直接、最准确的方式，其实是在构造函数内部利用
new.target
这个元属性来判断。如果对象已经创建出来了，我们通常会借助
instanceof
操作符，或者通过检查其原型链来推断，但这两种方法都有其局限性。
解决方案
判断一个对象是否通过
new
创建，最直接且推荐的做法是在其构造函数内部使用
new.target
。这个es6引入的特性，会在函数被
new
调用时指向被
new
调用的构造函数，如果函数是普通调用，则
new.target
为
undefined
。这让我们可以精确地控制构造函数的行为，甚至强制它必须通过
new
来调用。
举个例子，假设我们有一个
Person
构造函数：
function Person(name) { // 在这里判断 new.target if (!new.target) { // 如果没有使用 new 调用，则返回一个通过 new 创建的实例 console.warn("建议使用 new 关键字创建 Person 实例。"); return new Person(name); } this.name = name; console.log(`Person 实例 ${this.name} 已创建。`); } const person1 = new Person('Alice'); // 正常创建 const person2 = Person('Bob'); // 尝试不使用 new 创建，会被内部修正 console.log(person1 instanceof Person); // true console.log(person2 instanceof Person); // true
这种模式，在我日常写一些库或者框架的时候，用得特别多，它能有效避免用户误操作导致的问题。
如果对象已经创建，且我们无法修改其构造函数，那么
instanceof
是最常用的方法。它会检查对象的原型链上是否存在指定构造函数的
prototype
属性。
function Animal(type) { this.type = type; } const dog = new Animal('Dog'); const cat = new Animal('Cat'); console.log(dog instanceof Animal); // true console.log(cat instanceof Animal); // true const obj = {}; console.log(obj instanceof Animal); // false
但
instanceof
并非没有缺陷，它依赖于原型链的完整性，如果原型链被修改或者对象来自不同的 JavaScript Realm (比如 iframe)，它可能就不那么可靠了。
深入理解
new.target
new.target
：如何精准控制构造行为？
new.target
是一个非常精妙的语言特性，它不仅仅是用来判断“是否通过
new
创建”，更重要的是，它赋予了构造函数内部一个强大的自我感知能力。当一个函数被
new
操作符调用时，
new.target
会指向这个
new
表达式中直接被调用的构造函数。如果函数是作为普通函数被调用（没有
new
），那么
new.target
的值就是
undefined
。
这有什么用呢？在我看来，它最大的价值在于“防御性编程”和“弹性构造”。
防御性编程：强制使用
new
就像前面
Person
例子里展示的，我们可以利用
!new.target
来强制用户必须使用
new
来实例化对象。这避免了因为忘记
new
导致
this
指向全局对象（在非严格模式下）或者报错（在严格模式下），从而引发难以追踪的bug。
function Product(name, price) { if (!new.target) { // 没用 new？那我帮你 new 一个 console.warn("Product 构造函数必须通过 new 关键字调用！"); return new Product(name, price); } this.name = name; this.price = price; } const p1 = new Product('Laptop', 1200); // 正常 const p2 = Product('Mouse', 25); // 会被自动修正并警告 console.log(p1.name, p2.name);
这种做法，让你的API接口变得更加健壮，减少了用户的犯错空间。
弹性构造：根据调用方式调整行为
除了强制，
new.target
还能实现更灵活的构造逻辑。例如，你可以让同一个函数在
new
调用时作为一个构造函数，而在普通调用时作为一个工厂函数，返回一个预设的实例或者其他什么东西。
function Greeter(greeting) { if (new.target) { // 如果是 new 调用，初始化实例 this.greeting = greeting; console.log("Greeter 实例被构造"); } else { // 如果是普通调用，返回一个默认的 Greeter 实例 console.log("返回一个默认 Greeter 实例"); return new Greeter("Hello, default!"); } } const myGreeter = new Greeter("Hi there!"); console.log(myGreeter.greeting); // "Hi there!" const defaultGreeter = Greeter(); console.log(defaultGreeter.greeting); // "Hello, default!"
这让你的函数能够适应不同的使用场景，提供更友好的API。当然，这种灵活性也可能增加一点点理解成本，所以在使用时需要权衡。
instanceof
instanceof
并非万能：何时会失灵？
instanceof
操作符在日常开发中非常常用，它通过检查一个对象的原型链（
[[Prototype]]
内部属性）是否包含某个构造函数的
prototype
属性来判断实例关系。听起来很直观，但它确实有自己的局限性，尤其是在一些复杂或跨环境的场景下。
一个很常见的场景就是跨 Realm (跨域/iframe) 对象。每个 JavaScript Realm（比如一个浏览器窗口、一个 iframe 或者 Node.JS 的 vm 模块创建的上下文）都有自己独立的全局对象和内置构造函数。这意味着，一个在 iframe A 中创建的对象，即使它是
类型，在 iframe B 中使用
instanceof Array
来判断，结果也可能是
false
。因为这两个
Array
构造函数是不同的对象，它们的
prototype
属性也指向不同的原型对象。
<!-- index.html --> <iframe id="myFrame" src="about:blank"></iframe> <script> const iframe = document.getElementById('myFrame'); const iframeDoc = iframe.contentWindow.document; iframeDoc.write('<script>parent.myArrayInIframe = [];</script>'); iframeDoc.close(); setTimeout(() => { const arrInParent = []; const arrInIframe = window.myArrayInIframe; console.log(arrInParent instanceof Array); // true (在当前 Realm) console.log(arrInIframe instanceof Array); // false (来自不同 Realm 的 Array 构造函数) }, 100); </script>
你看，即使它们看起来都是数组，
instanceof
却给出了不同的结果。这在前端开发中，尤其是在涉及微前端或者嵌入第三方内容的场景下，是个需要特别注意的“坑”。
另一个是原型链被修改的情况。虽然不常见，但如果有人手动修改了对象的原型链，
instanceof
的结果也会变得不可靠。
function CustomObject() {} const obj = new CustomObject(); // 正常情况 console.log(obj instanceof CustomObject); // true // 修改原型链 Object.setPrototypeOf(obj, Object.prototype); console.log(obj instanceof CustomObject); // false (原型链被截断，CustomObject.prototype 不再在其中)
最后，如果你的目标是判断一个对象是不是“某个类型”的实例，而不是特指“通过
new
某个构造函数创建”，那么
instanceof
也可能不是最佳选择。比如，你可能想检查一个对象是否“可迭代”，这时候会更倾向于检查它是否有
symbol.iterator
方法，而不是它是不是
Array
或
的实例。
除了
new.target
new.target
和
instanceof
，还有哪些辅助方法？
当我们无法使用
new.target
(因为对象已经创建且我们无法修改构造函数)，并且
instanceof
又不够可靠时，还有一些辅助方法可以帮助我们进行更深层次的判断，或者说，从不同的角度来理解一个对象的“来源”或“类型”。
1. 使用
Object.getPrototypeOf()
检查原型链
Object.getPrototypeOf()
是一个非常实用的方法，它直接返回指定对象的原型（即
[[Prototype]]
内部属性的值）。结合
Object.prototype.isPrototypeOf()
，我们可以更灵活地检查一个对象是否在另一个对象的原型链上。
function MyConstructor() {} const myInstance = new MyConstructor(); // 检查 myInstance 的原型链上是否存在 MyConstructor.prototype console.log(MyConstructor.prototype.isPrototypeOf(myInstance)); // true // 也可以这样组合判断，虽然和 instanceof 效果类似，但理解起来更直接 console.log(Object.getPrototypeOf(myInstance) === MyConstructor.prototype); // true // 注意：这只检查直接原型，如果中间有继承，则不为 true // 而 isPrototypeOf 会检查整个原型链
isPrototypeOf
比
instanceof
更底层，因为它不涉及
constructor
属性或
Symbol.hasInstance
，只是纯粹地检查原型链关系。这在某些需要精确控制原型检查的场景下很有用。
2. 检查
constructor
属性（谨慎使用！）
每个对象通常都有一个
constructor
属性，指向创建该实例的构造函数。
function AnotherConstructor() {} const anotherInstance = new AnotherConstructor(); console.log(anotherInstance.constructor === AnotherConstructor); // true console.log(anotherInstance.constructor.name); // "AnotherConstructor"
然而，这个方法非常不推荐作为判断对象是否通过
new
创建的可靠依据。为什么呢？因为
constructor
属性是可写的，它很容易被修改、覆盖，或者在继承链中指向非预期的构造函数。
function Parent() {} function Child() {} Child.prototype = new Parent(); // 继承 Parent 的原型，但 constructor 没改 Child.prototype.constructor = Child; // 修正 constructor const childInstance = new Child(); console.log(childInstance.constructor === Child); // true console.log(childInstance.constructor === Parent); // false console.log(childInstance instanceof Child); // true console.log(childInstance instanceof Parent); // true // 如果 constructor 没修正，或者被恶意修改 function BadConstructor() {} const badInstance = new BadConstructor(); badInstance.constructor = String; // 随便改 console.log(badInstance.constructor === BadConstructor); // false console.log(badInstance instanceof BadConstructor); // true
所以，
constructor
属性更多是提供一个“线索”，而不是一个可靠的“证据”。
3. 添加自定义标记或属性
在某些特定场景下，如果你的设计允许，你可以在构造函数内部给实例添加一个私有（或伪私有）的标记，来明确它是否是通过
new
创建的。
function TaggedObject() { if (!new.target) { return new TaggedObject(); } this._isNewInstance = true; // 添加一个标记 // ... 其他初始化 } const tagInstance = new TaggedObject(); const nonTagInstance = TaggedObject(); // 也会被 new console.log(tagInstance._isNewInstance); // true console.log(nonTagInstance._isNewInstance); // true
这种方法完全依赖于你自己的约定和实现，但它在你知道所有可能的创建路径时，可以提供最直接、最可靠的“事后”判断依据。这就像在产品出厂时贴一个“合格证”，简单直接。
总的来说，判断一个对象是否通过
new
创建，最佳时机是在构造函数内部使用
new.target
。如果是在外部判断，
instanceof
是最常用的，但要警惕其局限性。而
Object.getPrototypeOf()
和自定义标记则提供了更精细或更具控制力的替代方案。
