深入了解new的过程，和call，apply，bind的区别

话不多数，直接上代码

//1、new的过程发生了什么
    function create () {
        //创建了一个对象
        var obj = new Object()
        //获取构造函数
        //shift用于把数组的第一个元素删除，并且返回第一个元素的值
        var Con = [].shift.call(arguments)
        //链接到原型
        obj.__proto__ = Con.protoptype
        //绑定this的指向
        let result = Con.apply(obj,arguments)
        //返回一个新的对象
        return typeof result === 'object' ? result : obj
    }
    //2、call、apply，bind的区别和用法
    var a = 1
    var obj = {
        a:2,
        fn () {
            console.log(this)
        }
    }
    //obj.fn.call(obj)
    //打印obj
    //会立即调用改变this的指向,普通函数this的指向指向调用它的那个对象
    //obj.fn.apply(obj)
    //f1.call(null,f2)
    var a = 1
    var obj2 = {
        a:2,
        fn () {
            console.log(this.a)
        }
    }
    //obj2.fn()
    //---2
    //var fn1 = obj2.fn
    //fn1()
    //---1
    //相信大家会有一点困惑，第一次this就指向它本身，自己调用，第二次this指向window
    //如果你传的context就null或者undefined，那么window对象就是默认的context（严格模式context就是undefined）
    //这也叫隐式的绑定，如果你希望打印2，修改为fn1.call(obj)
    //回调函数this的指向指向window
    //构造器模式，new一个函数时候，背地里会将新建的对象连接到prototype里，同时this会被绑定到那个对象上
    //call--方法第一个参数是绑定给this的值，后面传入的是一个参数的列表
    var obj3 = {
        message:'我的名字是：'
    }
    function getName (firstnmae,lastname) {
        console.log(this.message+firstnmae+''+lastname)
    }
    //getName.call(obj3,'武','泉')
    //apply--接受两个参数，第一个是要绑定this的值，第二个是一个参数数组
    var arr = [1,2,3,4,5,6]
    var max = Math.max.apply(this,arr)
    //console.log(max)
    //当第一个传入的是this，null，undefined时可以打印的是6
    //这里使用call打印的是NaN
    //bind--返回的是函数,不会被立即执行，返回的是一个改变了上下文this后的函数
    function bindfn (a,b,c) {
        console.log(a,b,c)
    }
    var binffn1 = bindfn.bind(this,'Doc')
    //binffn1('A','B','C')
    //Doc A B
    //binffn1('B','C')
    //Doc B C
    //说明bind后面的参数作为实参传进去了，后面的参数排队进
    //用bind实现函数珂里化
    var add = function (x) {
        return function(y){
            return x+y
        }
    }
    var addTen = add(9)
    //console.log(addTen(1))
    //10
    //低版本里没有bind，那么就自己手写一个
    if(!Function.prototype.bind){
        Function.prototype.bind = function () {
            //保留原函数
            var self = this
            //保存需要绑定this指向的上下文
            var context = [].shift.call(arguments)
            //剩余的参数转化为数组
            var args = [].slice.call(arguments)
            return function () {
                //解释一哈，返回一个新的函数，把context指向self，参数是上边保存的参数，拼接到一起
                self.apply(context,[].concat.call(args,[].slice.call(arguments)))
            }
        }
    }
    //[]就和Array.prototype差不多
    //console.log([]==Array)
    //false
    //console.log([] instanceof Array)
    //true
    //应用场景
    //求数组最大最小
    var arr = [1,2,3,89,46]
    var max = Math.max.apply(null,arr)//89
    var min = Math.min.apply(null,arr)//1
    //将伪数组转化为数组
    var trueArr = Array.prototype.slice.call(arrLike)
    //数组追加
    var arr1 = [1,2,3];
    var arr2 = [4,5,6];
    var total = [].push.apply(arr1, arr2);//6
    // arr1 [1, 2, 3, 4, 5, 6]
    // arr2 [4,5,6]
    //判断变量类型
    function isArray(obj){
        return Object.prototype.toString.call(obj) == '[object Array]';
    }
    isArray([]) // true
    isArray('dot') // false
    //利用call和apply做继承
    function Person(name,age){
        // 这里的this都指向实例
        this.name = name
        this.age = age
        this.sayAge = function(){
            console.log(this.age)
        }
    }
    function Female(){
        Person.apply(this,arguments)//将父元素所有方法在这里执行一遍就继承了
    }
    var dot = new Female('Dot',2)

 他说少于150字不允许发。。。

bind返回对应函数, 便于稍后调用； apply, call则是立即调用。

除此外, 在 ES6 的箭头函数下, call 和 apply 将失效, 对于箭头函数来说:

• 箭头函数体内的 this 对象, 就是定义时所在的对象, 而不是使用时所在的对象;所以不需要类似于var _this = this这种丑陋的写法
• 箭头函数不可以当作构造函数，也就是说不可以使用 new 命令, 否则会抛出一个错误
• 箭头函数不可以使用 arguments 对象,，该对象在函数体内不存在. 如果要用, 可以用 Rest 参数代替
• 不可以使用 yield 命令, 因此箭头函数不能用作 Generator 函数，什么是Generator函数可自行查阅资料，推荐阅读阮一峰Generator 函数的含义与用法，Generator 函数的异步应用