判断对象是否通过new创建，可以通过以下几种方式：1.使用instanceof操作符instanceof可以检查一个对象是否是某个类的实例。但要注意，它不能直接判断是否通过new创建，因为即使通过工厂函数创建的对象，只要其原型链指向该类，也会返回true。functionPerson(){}constp=newPerson();console.log(pinstanceofPerson);//tr

最近发现不少小伙伴都对文章很感兴趣，所以今天继续给大家介绍文章相关的知识，本文《如何判断对象是否通过new创建》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

最准确的判断方式是在构造函数内部使用 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() 和自定义标记则提供了更精细或更具控制力的替代方案。

到这里，我们也就讲完了《判断对象是否通过new创建，可以通过以下几种方式：1.使用instanceof操作符instanceof可以检查一个对象是否是某个类的实例。但要注意，它不能直接判断是否通过new创建，因为即使通过工厂函数创建的对象，只要其原型链指向该类，也会返回true。functionPerson(){}constp=newPerson();console.log(pinstanceofPerson);//trueconstp2=Object.create(Person.prototype);console.log(p2instanceofPerson);//true注意：这种方式不能区分new和Object.create()创建的对象。2.使用constructor属性每个对象都有一个constructor属性，指向创建它的构造函数。你可以通过这个属性来判断对象的来源。functionPerson(){}constp=newPerson();console.log(p.constructor===Person);//trueconstp2=Object.create(Person.prototype);console.log(p2.constructor===Person);//true同样，这种方式也无法区分new和Object.create()。3.使用Symbol.toStringTag（ES6）某些内置对象（如Array,Date,Map等）会定义Symbol.toStringTag属性，用于在Object.prototype.toString.call(obj)中显示类型》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！