this指向问题、new的过程

this的指向：

 谁调用就指向谁
 事件监听函数内部，this指向绑定事件监听的那个元素节点
 构造函数内部，this指向创建的新对象
 对于箭头函数，由于没有自身变量，this指向环境中的this
 一个函数没有前缀调用(被引用)，也就是普通调用，this指向全局变量。在严格模式下，this为undefine.

实例代码

// 全局下的this指向window
  console.log(this);
  // var a = 100;
  // window.a = 100;
  // this.a = 100;

  // 普通函数中的this,取决于，调用它的那个对象。
  // var name = '李四'

  // function fn() {
  //   var name = '张三';
  //   console.log(window.name)
  // }

  // fn();
  // 箭头函数中的this,不取决函数执行时，取决于函数定义是，时刻执行函数定义时父级的上下文。
  // let fn = () => {

  // }
  // var name = '李四'
  // var obj = {
  //   name: '张三',
  //   fn() {
  //     console.log(this.name)
  //   }
  // }
  // var pox = {
  //   name: '王五'
  // }

  //  call() 修改this指向。
  // obj.fn.call(pox);

  // obj.fn.call(pox);

  // function fn() {
  //   console.log(this)
  // }
  // let a = new fn();

  // class fn {
  //   constructor(name, age) {
  //     this.name = name;
  //     this.age = age;
  //     console.log(this)
  //   }
  //   eat() {
  //     console.log('i can eat');
  //   }
  // }

  // let a = new fn('张三', 20);

  // function Foo(name, age) {
  //   this.name = name;
  //   this.age = age;
  //   // return { name: name }
  // }
  // Foo.prototype.fn = function () {
  //   console.log(this.name)
  // }

  // let a = new Foo('张三', 20);

  // console.log(a);

  // function fn() {
  //   // 第一步：创建对象
  //   var obj = {};
  //   // 第二步：原型赋值
  //   obj.__proto__ = Foo.prototype;
  //   // 第三步：Foo函数执行，this指向obj对象，给obj添加属性。
  //   let result = Foo.call(obj, '张三', 20)
  //   // 第四步：判断构造函数是否返回对象数据类型，如果返回，则返回那个对象，如果没有返回则返回obj对象
  //   return typeof result === 'object' ? result : obj;
  // }
  // let b = fn();
  // console.log(b);

new关键字实例化过程

创建一个空对象 伪代码：let` obj = {}

将该对象的__proto__指向类的原型对象 伪代码：obj.__proto__ = A.prototype

绑定该函数内部的this，指向这个对象 伪代码：this.obj

执行函数，并且将this作为返回值返回 伪代码：/执行代码/：return this

new的过程都干了什么

new的过程

新生成一个对象

连接到原型(继承该函数的原型)

绑定this(将原型中的属性和方法加入到this引用的对象中)

返回新对象

自己实现一个new

function create() {
    // 创建一个空的对象
    let obj = new Object()
    // 获得构造函数
    let Con = [].shift.call(arguments)
    // 设置新对象的__proto__属性指向构造函数的prototype属性
    obj.__proto__ = Con.prototype
    // 绑定 this，函数中this指向新实例对象。
    let result = Con.apply(obj, arguments)
    // 确保 new 出来的是个对象
    return typeof result === 'object' ? result : obj
}

简单版

function newFunc(constructor){
  //第一步：创建一个空对象obj 
    var obj = {};
   //第二步：将构造函数 constructor的原型对象赋给obj的原型
    obj.__proto__ = constructor.prototype;
  //第三步：将构造函数 constructor中的this指向obj,并立即执行构造函数内部的操作
    constructor.apply(obj);
  //第四步：返回这个对象
    return obj;
}