this指针

this指针

普通this指针指向问问题：

1.预编译过程中的this–>window

2.全局作用域中的this–>window

3.一般情况下的this–>调用者(谁调用指向谁)；

4.call/apply，改变this指向，指向第一个参数

5.object.function(){} this–>object;

6.普通函数中的this，是window;

7.对象.方法中的this是当前对象；

8.定时器的this是window；

9.构造函数中的this是实例对象；

10.原型对象中的this是实例对象。

全局环境下的this

在全局环境下，this指针始终指向的全局对象(window)；

console.log(this===window);//true

函数上下文调用

函数直接调用

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

非严格模式下，this指向window;

function fn(){
    return this;
}
fn()===window; //true

严格模式下，this指向undefined

function fn(){
  "use strict"; // 这里是严格模式
  return this;
}
 
fn() === undefined; // true

对象中的this

对象内部方法的this指向调用这些方法的对象，

1. 函数的定义位置不影响其this指向，this指向只和调用函数的对象有关。

2. 多层嵌套的对象，内部方法的this指向离被调用函数最近的对象（window也是对象，其内部对象调用方法的this指向内部对象， 而非window）。

   var name = ‘lisi’
   var obj = {
   name : ‘zhangsan’,
   say : function(){
   console.log(this.name) //zhangsan
   self = function(){
   console.log(this.name) //lisi
   }
   self();
   },
   }
   obj.say();

在上面的例子中，是obj调用的say()这个方法，第一个console.log(this.name)中的this指向的就是obj，因此，this.name=obj=name，结果为zhangsan。

第二个console.log(this.name)，self是一个独立的函数，而且后面是该函数的自执行，并没有人调用，所以该函数里的this指向window，所以self里面的this.name==window.name的结果是lisi

接下来我们看一个更加复杂的例子：

		var name = '222'
		var a = {
			name : '111',
			say : function(){
				console.log(this.name);
			}
		}
		var fun = a.say;
		fun();    //222
		a.say();    //111
		var b = {
			name : '333',
			say : function(fun){
				fun();
			}
		}
		b.say(a.say);    //222
		b.say = a.say;
		b.say();    //333

第一个this指针：

var fun = a.say;
fun();

上面代码相当于：

var fun = function(){
    console.log(this.name);
}

因此this指向的是window;

第二个this指针:

a.say()此时this指针指向调用者a，很明显这里的this.name == a.name

第三个this指针

b.say(a.say);

b.say()可以认为和下面代码是一样的：

b.say:function(fun){
    this;//b
    func();
}

这里的this确实是指向了b，但是a.say是作为参数传进b.say然后自执行，所以a.say里面的this与b.say没有任何关系，这里的this.name == window.name;

####第四个this指针

最后一个b.say = a.say，这里可以理解为b.say利用a.say重新定义了自己的方法，所以这里的b.say为：

 b.say = function(){
	console.log(this.name);
}

这里的this指向的是调用者b，因此this.name=b.name=333