This 的概念

1. 在js 中，this的意思为：‘这个，当前’，是一个指针型 变量，它动态指向当前函数的运行环境
2. 在不同的场景中调用同一个函数，this 的指向也可能发生变化，但是它永远指向其所在函数的真实调用者；如果没有调用者，就指向全局对象 window

普通函数：关于 this,谁调用就指向谁，没有调用者，就指向全局对象window

箭头函数：箭头函数的this指向于函数作用域所用的对象

一：全局环境下的this指向：this始终指向window，无论是否是严格模式

       Console.log(this)://window

       Window.console.log(this)//window下的console方法

    Console.log()完整的写法是 window.console.log()，window可以省略，window调用了      console.log（）方法，所以此时this指向window

二：函数内的this：普通的函数内的this分为两种情况，严格模式下和非严格模式下

      严格模式下：

        Function test (){ ‘user strict’ console.log(this)}

        test();  //undefined

        window.test();//window

       严格模式下，直接test（）调用函数，this指向 undefined，window.test()调用函数指向window，因此，在严格模式下，我们对代码的调用必须严格的写出被调用的函数的对象，不可以省略或者说简写

     非严格模式下：

      Function test(){ console.log(this)}

      test() //window

      window.test()//window

非严格模式下，通过test（）和window.test()调用函数对象，this都指向window

三：对象中的this：对象内部方法的this指向调用这些方法的对象，也就是谁调用就指向谁

1. 一层对象：

Let obj={ name:‘蒙蚜“，skill:function(){ name:”盟栝“ console.log(this.name)}}

       obj.skill() //蒙蚜

 调用obj.skill()方法，返回的值是蒙蚜，说明此时this 指向的是obj

     2.二层对象：

Let obj={name:“蒙蚜”，skill：function(){name:”盟栝“；console.log(this.name)};obj2:{}name:”小卤蛋“，skill2:function(){name:”鲁班大师“，console.log(this.name)}}}

        Obj.skill();//蒙蚜

        Obj.obj2.skill2();//小卤蛋

 内部方法的this指向离被调用函数最近的对象，调用skill2()方法的顺序为：obj.obj2.skill2(),返回值为小卤蛋，说明skill2（）方法中的this指x向obj2

总结：1.函数的定义不影响其this的指向，this指向只和调用函数的对象有关

           2.多层嵌套的对象，内部方法的this指向离被调用函数最近的对象

四：箭头函数中的this：指向于函数作用域所用的对象

       箭头函数的重要特征：箭头函数中没有this he arguments，是真的没有

       箭头函数没有自己的this指向，它会捕获自己定义所处的外层执行环境，并且继承这个this值，指向当前定义时所在的对象，箭头函数的this指向被定义的时候就确定了，之后永远也不会改变。即使使用call(),apply(),bind()等方法改变this指向也不行

例1

Var isObject={ a:’hhh’,functions}{console.log(“对象“，this}}

isObject.functions() //对象 window

声明的是全局变量Obj,this指向箭头函数所在全局作用域的对象，即window对象

例2

Let show=()=>{console.log(this)}

Let obj={show:show}

等同于 obj={ show: ()=>{console.log(this)}

Show() //window

Window.show()//window

Obj.show();//window

Window.obj.show()//window

1. 由于 show 函数是箭头函数，所以自身不能绑定this,因此找它的上一级作用域。如果父级作用域还是箭头函数，就再往上找，一层一层的直到this 的指向。
2. Window.show()返回值是window,所以this 此时指向window
3. Window.obj.show(),obj是对象，非箭头函数，所以找到这里就停了，this绑定在obj 上。Window 调用obj,所以obj 中的this也指向window

五 构造函数中的this ;指向实例

构造函数中的this

补充：构造函数的函数名首字母大写，便于区别普通函数

Function Person(name,age,sex){ this.name=name;this.age=age;this.sex=sex}

补充：构造函数必须中实例必须用new声明

Let p=new Person(“wcc”,18,”boy”)

Console.log(p.age) //18

Console.log(p.name)//wcc

Console.log(p.sex)//boy

由上图可以看得出，构造函数中的this指向构造函数下创建的实例

六 原型链中的this：this 这个值在一个继承机制中，仍然是指向它原本属于的对象，而不是从原型链上找到它时，它所属的对象

七 改变 this指向的方法

  1.call(a,b,c) 方法接收三个参数，第一个是 this 指向，第二个，第三个是传递函数的实参，可以是数字，字符串，数组等类型的数据类型都可以

       Function fn(n1,n2){console.log(this);;console.log(n1,n2)}

       Fn.call() //this:window

       Let obj={fn:fn}

       Fn.call(obj)//this:obj;n1,n2:undefined

       Fn.call(1,2)//this:1,n1=2,n2=undefined

       Fn.call(obj,1,2) //this:obj,n1=1,n2=2

Call方法的几种特殊属性

非严格模式下：fn.call(undefined);//this=>window

              Fn.call(null)//this=>window

严格模式下：fn.call(undefned) //this=>undefined

Use strict              Fn.call(null):/this=>null

2.apply(a,[b]) 和call基本上一致，唯一的区别在于传参方式，apply把需要传递给fn（）的参数放到了一个数组（或者类数组）中传递进去，虽然写了一个数组，但是也相当于给fn()一个个的传递

 Fn.call(obj,1,2)

 Fn.apply(obj,[1,2])

Function fn(n1,n2){console.log(this);console.log(n1,n2);console.log(arguments)}

Let obj={fn:fn}

Fn.apply(abj,[1,2])

 fn.apply(abj,1,1)//报错

fn.apply(abj,[11,’appply’,{a:123}]) //第二个参数必须是数组，否则会报错

1. bind()

bind(a,b,c):语法和call 一摸一样，区别在于立即执行还是等待执行，bind不兼容IE6-IE8

bind和call的唯一区别在于就是 call 直接改变函数 test 的指向，而bind 是生成一个新函数 test2()，该函数改变了指向

//call()方法：改变fn 中this，并且把fn 立即执行

Fn.call(obj,1,2)

//apply()方法：改变fn中的this,fn 并不执行

Fn.bind(obj,1,2)

示例：

Bind 和 call方法调用形式类似，但是原理完全不同

Fn.call(obj,10,20) //fn 先执行，将 fn 内的this指向obj,并且把参数10，20传递给fn

Fn.bind(obj,10,20)//bind是先将fn 中的this指向obj,并且将参数 10,20预先传递给fn,但是此时的fn 并没有被执行，只有fn 执行时 this指向和传递参数才有作用

Fn.bind(obj,10,20) //不会有任何输出

Fn.bind(obj,10,20)();//调用后才会有输出

需求：点击box 这个盒子盒子的时候，需要执行fn,并且让fn 中的this 指向obj

oBox.onClick=fn; //点击的时候执行了fn,但此时fn 中的this是oBox

oBox.onClick=fn.call(opp);//绑定事件的时候就已经把fn 立即执行了（call 本身就是立即执行函数），然后把fn 执行的返回值绑定给事件

oBox.onClick=fn.bind(opp); //fn.bind(opp);fn调取funciton.prototype上bind方法，执行这个 //function(){fn.call(opp)}

oBox.onClick=function(){this:oBox;fn.call(opp)}//

相同点：

Call,apply和bind 都是JS函数的公有的内部方法，他们都是重置函数的this,改变函数的执行环节。

不同点：

Bind 是创建一个新的函数，而call和apply是用来调用函数

Call 和apply 作用一样，只不过call为函数提供的参数是一个个地罗列出来，而apply为函数提供的参数是一个数组