作者：奥兰度

    1. function myNew(constructor, ...args) {
    2.   // 非函数
    3.   if (typeof constructor !== 'function') {
    4.     throw new Error(`Uncaught TypeError: ${constructor} is not a constructor`)
    5.   }
    6.   // 箭头函数
    7.   if (!constructor.prototype) {
    8.     throw new Error(`Uncaught TypeError: ${constructor.name} is not a constructor`)
    9.   }
    10.   const newObj = Object.create(constructor.prototype)
    11.   const result = constructor.apply(newObj, args)
    12.   // 返回值是 object
    13.   if (typeof result === 'object' && !!result) {
    14.     return result
    15.   } 
    16.   // 返回值不是 object
    17.   return newObj
    18. }

    作者：安静

    1. function customNew<T> (constructor: Function, ...args: any[]): T {
    2.   // 创建空对象继承原型
    3.   const obj = Object.create(constructor.prototype);
    5.   // 将 obj 做 this 执行 constructor
    6.   const res = constructor.apply(obj, args);
    8.   // 如果构造函数有返回值，就使用返回值，否则使用 obj
    9.   return res ?? obj;
    10. }
    12. class Foo {
    13.   name: string;
    14.   age: number;
    16.   constructor(name: string, age: number) {
    17.     this.age = age;
    18.     this.name = name;
    19.   }
    21.   getName() {
    22.     return this.name;
    23.   }
    24. }
    26. const f1 = customNew<Foo>(Foo, '安静', 18);
    27. console.log(f1);
    28. console.log(f1.getName());

    作者：xl

    1. function objectFactory() {
    2.   let newObject = null;
    3.   let constructor = Array.prototype.shift.call(arguments);
    4.   let result = null;
    5.   // 判断参数是否为函数
    6.   if (typeof constructor !== "function") {
    7.     console.log("type error");
    8.     return;
    9.   }
    10.   // 新建一个空对象，对象的原型为构造函数的 prototype 对象
    11.   newObject = Object.create(constructor.prototype);
    12.   // 将 this 指向新建对象，并执行函数
    13.   result = constructor.apply(newObject, arguments);
    14.   // 判断返回对象
    15.   let flag = result && (typeof result === "object" || typeof result === "function");
    16.   // 判断返回结果
    17.   return flag ? result : newObject;
    18. }

    作者：寥寥

    1. function myNew(fn, ...args) { 
    2.   if (typeof fn !== 'function') { 
    3.     throw 'fn must be a function'
    4.   }
    5.   let obj = new Object();   
    6.   // 将实例对象的__proto__指向构造函数的原型对象
    7.   obj.__proto__ = Object.create(fn.prototype)
    8.   // 构造函数的this指向实例对象
    9.   let res = fn.call(obj, ...args);
    10.   if (res && (typeof res === 'object' || typeof res === 'function')) { 
    11.     return res;
    12.   }
    13.   return obj;
    14. }

    作者：Leo

    1. function Factory() {this.a = 1} 
    3. function Factory() {return {b : 3}} 
    4. function Factory() {this.a = 1; return {a : 3}} 
    6. const a = new Factory()

    作者：
    作者：
    作者：
    作者：