最准确的判断方式是在构造函数内部使用 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创建”，更重要的是，它赋予了构造函数内部一个强大的自我感知能力。当一个函数被
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操作符在日常开发中非常常用，它通过检查一个对象的原型链（
[[Prototype]]内部属性）是否包含某个构造函数的
prototype属性来判断实例关系。听起来很直观，但它确实有自己的局限性，尤其是在一些复杂或跨环境的场景下。
一个很常见的场景就是跨 Realm (跨域/iframe) 对象。每个 JavaScript Realm（比如一个浏览器窗口、一个 iframe 或者 Node.js 的 vm 模块创建的上下文）都有自己独立的全局对象和内置构造函数。这意味着，一个在 iframe A 中创建的对象，即使它是
Array类型，在 iframe B 中使用
instanceof Array来判断，结果也可能是
false。因为这两个
Array构造函数是不同的对象，它们的
prototype属性也指向不同的原型对象。
');
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);
你看，即使它们看起来都是数组，
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或
Map的实例。
除了 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()和自定义标记则提供了更精细或更具控制力的替代方案。
