1. 通过对象调用函数，this指向对象
    2. 直接调用函数，this指向全局对象
    3. 如果通过new调用函数，this指向新创建的对象
    4. 如果通过apply、call、bind调用函数，this指向指定的数据
    5. 如果是DOM事件函数，this指向事件源

    **
    bind():
    bind(this指向，参数)
    绑定this指向并且返回一个新函数，在bind()的里的参数会插入到执行函数的arguments的之前那参数的前面，但是bind的之后在new的话this指向将无效。绑定this指向之后假如之后多次调用this的指向都是绑定的this, call与apply 只是修改this指向，下次重新调用this指向就是原来的this指向，需要重新修改this指向

    1.         var x = 10 ;
    2.         function show(){
    3.             console.log(this.x)
    4.         };
    5.         show();
    6.         var dyio={
    7.             x:20,
    8.         };
    9.         var newshow = show.bind(dyio);
    10.         console.log(new newshow().construtor); //此时this指向无效

    bind的原理如下：

    1.         Function.prototype.newBind = function(target){
    2.             // 谁调用newBind的this指向就是谁 
    3.             var self = this;  // this指向是show
    4.             var arg = [].slice.call(arguments,1)//将传递给函数的参数的类数组对象从类数组第一位将其提取出来
    5.             var temp =function(){};
    6.             var f = function(){
    7.                 var _arg = [].slice.call(arguments,0) // 接受第二次参数
    8.                  //修改this指向，并且合并参数，会让第二次参数在其第一次参数的末尾添加
    9.                 return self.apply(this instanceof temp ? this : (target|| window),arg.concat(_arg));
    10.                 // return self.apply(target) 当 new 的时候 constructor会显示此对象的函数引用为  var f = function(){}
    11.             }
    12.             // 继承 防止new之后创建此对象的 Boolean 函数的引用为var f = function(){}
    13.             temp.prototype = self.prototype;
    14.             f.prototype = new temp();
    15.             return f; // 形成闭包
    16.         }
    17.         function show (){
    18.             console.log(this)
    19.         }
    20.         var duyio = {
    21.             x:20,
    22.         }
    23.         var newSbow = show.newBind(duyio,1,2,3);
    24.         newSbow(5); //第二次参数 会将第一次的参数插入第二次参数的前面
    25.         console.log(new newSbow().constructor) // 此处的函数引用是 show()
    26.                 //constructor 属性返回对创建此对象的 Boolean 函数的引用