模拟new的实现

new运算符创建一个用户定义的对象类型的实例或具有构造函数的内置对象类型之一

模拟new之前，看看new实现了哪些功能

// Otaku 御宅族，简称宅
function Otaku (name, age) {
    this.name = name;
    this.age = age;

    this.habit = 'Games';
}

Otaku.prototype.strength = 60;

Otaku.prototype.sayYourName = function () {
    console.log('I am ' + this.name);
}

var person = new Otaku('Kevin', '18');

console.log(person.name) // Kevin
console.log(person.habit) // Games
console.log(person.strength) // 60

person.sayYourName(); // I am Kevin

例子可以看出 person 可以：

1. 访问到Otaku构造函数里的属性
2. 访问到Otaku.prototype中的属性

尝试模拟：
因为new是关键字，所以无法像bind函数一样直接覆盖， 所以我们写一个函数，命名为objectFactory，来模拟new的效果。用的时候是这样：

function Otaku () {
    ……
}

// 使用 new
var person = new Otaku(……);
// 使用 objectFactory
var person = objectFactory(Otaku, ……)

初步实现：

1. 访问到Otaku构造函数里的属性：
   分析，因为new的结果是一个新对象，所以在模拟实现的时候，我们也要建立咦个新对象，假设这个对象叫 obj, 因为obj会具有 Otaku 构造函数里的属性， 所以我们可以用Otaku.apply(obj, arguments)来给obj添加属性
   2.访问到Otaku.prototype中的属性：
   分析，我们知道实例的proto属性会指向构造函数的prototype，也正是因为建立起这样的关系，实例可以访问原型上的属性。

// 第一版代码
function Otaku (name, age) {
            this.name = name;
            this.age = age;
            this.habit = 'Games';
        }

        Otaku.prototype.strength = 60;
        Otaku.prototype.sayYourName = function () {
            console.log('I am ' + this.name);
        }

        function objectFactory() {
            var obj = new Object(), // new返回的是一个对象，所以定义一个对象，最后返回该对象
            Constructor = [].shift.call(arguments); // shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。并且会改变原来数组的长度，  Constructor = Otaku构造函数
            Constructor.apply(obj, arguments); // obj 有 Constructor（即Otaku构造函数）的属性， obj有了Otaku的执行环境， 此行并不能去掉
            console.log(obj instanceof Constructor); // false 此时还不是它的实例
            obj.__proto__ = Constructor.prototype; // obj 就继承了 Constructor.prototype（即Otaku构造函数）
            console.log(obj instanceof Constructor); // true  
            return obj; // 最后返回该对象：1. obj访问到Otaku构造函数里的属性; 2. obj访问到Otaku.prototype中的属性  实现了new功能
        };

        var person = objectFactory(Otaku, 'Kevin','18');
        
        console.log(person.name) // Kevin
        console.log(person.habit) // Games
        console.log(person.strength) // 60

        person.sayYourName(); // I am Kevin

这里复习一下实例proto属性,

// 复习一下实例__proto__属性， 改变实例的__proto__指向，则就继承了指向的原型对象属性方法
        function Person (){
            this.habit = 'Games'
        }
        Person.prototype.name = 'jack';
        Person.prototype.age = 19;

        function Person1 (){
            this.name = 'Ailse'
        }
        Person1.prototype.age = 18

        var a = new Person();
        var b = new Person();

        a.__proto__ = Person1.prototype; // 改变实例的__proto__指向，则就改变了实例的类型
        console.log(a.__proto__ === Person1.prototype); // true
        console.log(a instanceof Person); //false
        console.log(a instanceof Person1); //true
        console.log(a.name); // undefined   并没打印Person1的 Ailse,  
        console.log(a.age); // 18
        console.log(a.habit); // Games  Person new出来的对象， 执行上下文环境给了a

返回值效果实现

加入构造函数有返回值：

function Otaku (name, age) {
            this.strength = 60;
            this.age = age;
        
            return {
                name: name,
                habit: 'Games'
            } // 构造函数返回了一个对象，在实例 person 中只能访问返回的对象中的属性。
            // return "beautiful girl" // 返回一个基本类型的值，等于是没有返回了，new 实例正常访问属性
        }
        
        // var person = new Otaku('Kevin', '18');

        function objectFactory() {
            var obj = new Object(),
            Constructor = [].shift.call(arguments);
            obj.__proto__ = Constructor.prototype;
            var ret = Constructor.apply(obj, arguments);
            console.log(ret);
            console.log(typeof ret);
            return (typeof ret === 'object' ? ret : obj);
        };
        
        var person = objectFactory(Otaku, 'Kevin', '18')

        
        console.log(person.name) // Kevin
        console.log(person.habit) // Games
        console.log(person.strength) // undefined
        console.log(person.age) // undefined

面试题：模拟new实现的思路
关键点：

• 1. 访问到Otaku构造函数里的属性
• 2.访问到Otaku.prototype中的属性

function objectFactory() {
            var obj = new Object(), // new返回的是一个对象，所以定义一个对象，最后返回该对象
            Constructor = [].shift.call(arguments); // shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。并且会改变原来数组的长度，  Constructor = Otaku构造函数
            Constructor.apply(obj, arguments); // obj 有 Constructor（即Otaku构造函数）的属性， obj有了Otaku的执行环境， 此行并不能去掉
            console.log(obj instanceof Constructor); // false 此时还不是它的实例
            obj.__proto__ = Constructor.prototype; // obj 就继承了 Constructor.prototype（即Otaku构造函数）
            console.log(obj instanceof Constructor); // true  
           //  return obj; // 最后返回该对象：1. obj访问到Otaku构造函数里的属性; 2. obj访问到Otaku.prototype中的属性  实现了new功能

return (typeof ret === 'object' ? ret : obj); // 如果是一个对象，我们就返回这个对象，如果没有，我们该返回什么就返回什么。
        };