参考：阮一峰《javascript的this用法》及《JS中this关键字详解》
this是Javascript语言的一个关键字它代表函数运行时，自动生成的一个内部对象，只能在函数内部使用。定义：this是包含它的函数作为方法被调用时所属的对象。总原则，this指的是，调用函数的那个对象，this永远指向函数运行时所在的对象！而非创建时的。
以下是基于浏览器环境做的测试：
作为函数调用：
function $(){
this.count = 1;
return this;
}
window.onload = function(){
console.info($());
}
控制台返回结果如下：
一个window对象。
对于内部函数，即声明在另外一个函数体内的函数，这种绑定到全局对象的方式会产生一个问题，即它会隐式声明全局变量。代码如下：
var point = {
x: 0,
y: 0,
moveTo: function(x, y) {
var fn1 = function(x) {
this.x = this.x + x;
return this.x;
};
var fn2 = function(y) {
this.y = this.y + y;
};
return fn1();
}
}
console.log(point.moveTo());
结果是：
而若将fn1中return的值改为this的话，打印结果：
一个window全局对象。这属于 JavaScript 的设计缺陷，正确的设计方式是内部函数的 this 应该绑定到其外层函数对应的对象上，这个设计错误错误的后果是方法不能利用内部函数来帮助它工作，因为内部函数的this被绑定了错误的值，所以不能共享该方法对对象的访问权。为了规避这一设计缺陷，聪明的 JavaScript 程序员想出了变量替代的方法，约定俗成，该变量一般被命名为 that。如下：
var point = {
x: 0,
y: 0,
moveTo: function(x, y) {
var that = this;
var x = x;
var y = y;
var fn1 = function(x) {
that.x = that.x + x;
return that;
};
var fn2 = function(y) {
that.y = that.y + y;
};
return fn1(x);
}
}
console.log(point.moveTo(1,1));
返回结果：
函数调用中，this总是指向函数的直接调用者（而非间接调用者）。如果在严格模式下，有可能输出undefined，严格模式下，禁止this关键字指向全局对象。如下：
'use strict';
console.log(this === window); // true
var foo = function() {
console.log(this === window);
console.log('this:',this);
};
foo();
window.foo();
控制台打印结果是：
使用that的另一个例子：
var myObj = {
value: 0,
increment: function(inc) {
this.value += typeof inc === 'number' ? inc: 1;
}
}
myObj.increment();
document.writeln(myObj.value);
myObj.increment(2);
document.writeln(myObj.value);
function add(num1, num2){
return num1 + num2;
}
console.log(add(40,27));
myObj.double = function() {
var that = this;
var helper = function() {
that.value = add(that.value, that.value);
}
helper();
}
myObj.getValue = function() {
var that = this;
return that.value;
}
myObj.double();
document.writeln(myObj.getValue());
作为对象方法调用：
如果一个调用表达式包含一个属性存取表达式（即一个.点表达式或者[subscript]下标表达式）,那么它被当做一个方法来调用。另一段代码：
var o = {};
o.fn = $;
function $(){
console.log(this);
}
window.onload = function(){
o.fn();
}
控制台返回结果如下：
调用函数的o对象。
在事件中，this指向触发这个事件的对象，特殊的是，IE中的attachEvent中的this总是指向全局对象Window；
另外一种嵌套调用：
var personA={
name:"xl",
showName:function(){
console.log(this.name);
}
}
var personB={
name:"XL",
sayName:personA.showName
}
personB.sayName();
控制台输出结果：
从这里很明显的看出，在js中this关键字指向是直接调用它的对象，而非间接的。
作为函数及对象方法的混合调用：
var myObject={
foo : "",
func : function(){
var self = this;
console.log("outer func : this.foo = " + this.foo );
console.log("outer func : self.foo = " + self.foo );
(function(){
console.log("inner func : this.foo = " + this.foo );
console.log("inner func : self.foo = " + self.foo );
}());
}
}
myObject.func();
输出结果如下：
证明函数内部函数的调用是由全局对象引发的，这在上面有所阐述。
将构造函数作为函数调用：
function Person(name) {
this.name = name;
}
var personA = Person("xl");
// console.log(personA.name);
console.log(window.name);
console.log(name);
var personB = new Person("xl");
console.log(personB.name);
控制台打印结果：
注释掉的console因为那么已经成为全局对象的属性，因此打印为未定义变量报错。第二个显式调用，第三个隐式调用。最后一个则是作为构造方法调用。
作为构造函数调用：
JavaScript 支持面向对象式编程，与主流的面向对象式编程语言不同，JavaScript 并没有类（class）的概念，而是使用基于原型（prototype）的继承方式。相应的，JavaScript 中的构造函数也很特殊，如果不使用 new 调用，则和普通函数一样。作为又一项约定俗成的准则，构造函数以大写字母开头，提醒调用者使用正确的方式调用。如果调用正确，this 绑定到新创建的对象上。
通过new实例化一个函数：
function $(){
console.log(this);
}
var fn = new $();
控制台输出如下：
this就指这个新对象。
使用apply或call调用：
使用apply方法（（当然使用Function.call也是可以的）），另一个方法 call 也具备同样功能，不同的是最后的参数不是作为一个数组统一传入，而是分开传入的。这两个方法异常强大，他们允许切换函数执行的上下文环境（context），即 this 绑定的对象。很多 JavaScript 中的技巧以及类库都用到了该方法。
function $(){
console.log(this);
}
var o = {};
o.m = $;
o.m.apply();
控制台打印结果：
注：Function.apply(obj,args)方法能接收两个参数
obj：这个对象将代替Function类里this对象
args：这个是数组，它将作为参数传给Function（args-->arguments）
apply()的参数为空时，默认调用全局对象。
如果将call的第一个destination的值设为一个对象，如下：
function $(){
console.log(this);
}
var u = {};
var o = {};
o.m = $;
o.m.apply(u,null);
控制台打印结果如下：
也即this指向了apply绑定的那个对象。
作为构造函数及apply/call的混用：
//下面这段代码模拟了new操作符(实例化对象)的内部过程
function person(name){
var o={};
o.__proto__=Person.prototype; //原型继承
Person.call(o,name);
return o;
}
var personB=person("xl");
console.log(personB.name); // 输出 xl在person里面首先创建一个空对象o，将o的proto指向Person.prototype完成对原型的属性和方法的继承。Person.call(o,name)这里即函数Person作为apply/call调用(具体内容下方)，将Person对象里的this改为o，即完成了o.name=name操作。返回对象o。
作为回调函数的this：
我们来看看 this 在 JavaScript 中经常被误用的一种情况：回调函数。JavaScript 支持函数式编程，函数属于一级对象，可以作为参数被传递。请看下面的例子 myObject.handler 作为回调函数，会在 onclick 事件被触发时调用，但此时，该函数已经在另外一个执行环境（ExecutionContext）中执行了，this 自然也不会绑定到 myObject 对象上。
button.onclick = obj.handler;
代码如下：
<p id="p">click me</p>
<script type="text/javascript">
var obj = {
handler: function() {
console.log(this);
}
}
var p = document.getElementById("p");
p.onclick = obj.handler;
执行结果如下：
很显然指向是触发click事件的dom元素对象，而非obj对象。这是 JavaScript 新手们经常犯的一个错误，为了避免这种错误，许多 JavaScript 框架都提供了手动绑定 this 的方法。比如 Dojo 就提供了 lang.hitch，该方法接受一个对象和函数作为参数，返回一个新函数，执行时 this 绑定到传入的对象上。使用 Dojo，可以将上面的例子改为：button.onclick = lang.hitch(myObject, myObject.handler);在新版的 JavaScript 中，已经提供了内置的 bind 方法供大家使用。
eval方法中this的指向：
JavaScript 中的 eval 方法可以将字符串转换为 JavaScript 代码，使用 eval 方法时，this 指向哪里呢？答案很简单，看谁在调用 eval 方法，调用者的执行环境（ExecutionContext）中的 this 就被 eval 方法继承下来了。
var name="XL";
var person={
name:"xl",
showName:function(){
eval("console.log(this.name)");
}
}
person.showName(); //输出 "xl"
var a=person.showName;
a(); //输出 "XL"
第一次的执行环境是person对象，第二个是global全局环境。
Function.prototype.bind()方法：
1.var name = "XL";
function Person(name) {
this.name = name;
console.log(this);
this.sayName = function() {
console.log(this);
setTimeout(function(){
console.log(this);
console.log("my name is " + this.name);
},50)
}
}
var person = new Person("xl");
person.sayName();
2.var name="XL";
function Person(name){
this.name=name;
this.sayName=function(){
setTimeout(function(){
console.log("my name is "+this.name);
}.bind(this),50) //注意这个地方使用的bind()方法，绑定setTimeout里面的匿名函数的this一直指向Person对象
}
}
var person=new Person("xl");
person.sayName(); //输出 “my name is xl”;
这里setTimeout(function(){console.log(this.name)}.bind(this),50);,匿名函数使用bind(this)方法后创建了新的函数，这个新的函数不管在什么地方执行，this都指向的调用它的对象,而非window。而如果不加bind在第一段代码中，window执行环境中创建了一个变量person，被赋值了Person的实例，此时的调用顺序是person调用了sayName这个方法，这个方法被赋值了一个函数（此处有问题，该赋值函数是匿名还是非匿名？下篇讨论），创建了一个执行环境，此时setTimeOut函数开始执行，创建一个环境。匿名函数及setTimeout/setInterval在非手动改变指向额情况下都在全局作用域当中。
SO，第一段代码的打印结果是：
sf的解释：setTimeout/setInterval/匿名函数执行的时候，this默认指向window对象，除非手动改变this的指向。在《javascript高级程序设计》当中，写到：“超时调用的代码(setTimeout)都是在全局作用域中执行的，因此函数中的this的值，在非严格模式下是指向window对象，在严格模式下是指向undefined”。本文都是在非严格模式下的情况。
第二段代码的打印结果是：
这相当于手动将this进行了强制转向。
另一种手动转向的方法：
var name="XL";
function Person(){
this.name="xl";
var that=this;
this.showName=function(){
console.log(that.name);
}
setTimeout(this.showName,50)
}
var person=new Person(); //输出 "xl"
借用了上面提到的that保存this指针值进行复用的技巧。
匿名函数中的this：
var name="XL";
var person={
name:"xl",
showName:function(){
console.log(this.name);
}
sayName:function(){
(function(callback){
callback();
})(this.showName)
}
}
person.sayName(); //输出 XL
var name="XL";
var person={
name:"xl",
showName:function(){
console.log(this.name);
}
sayName:function(){
var that=this;
(function(callback){
callback();
})(that.showName)
}
}
person.sayName() ; //输出 "xl"
此处采用了that技巧保存this指针。
箭头函数（点击这里）：
箭头函数看上去是匿名函数的一种简写，但实际上，箭头函数和匿名函数有个明显的区别：箭头函数内部的this是词法作用域，由上下文确定。示例代码：
var obj = {
birth: 1990,
getAge: function (year) {
var b = this.birth; // 1990
var fn = (y) => y - this.birth; // this.birth仍是1990
return fn.call({birth:2000}, year);
}
};
console.log(obj.getAge(2015)); // 25
控制台打印结果：
this的四种使用场景
面向对象的语言中，this 关键字的含义是明确且具体的，即指代当前对象。一般在编译期确定下来，或称为编译期绑定。而在 JavaScript 中，this 是动态绑定，或称为运行期绑定，这就导致 JavaScript 中的 this 关键字有能力具备多重含义，它可以是全局对象、当前对象或者任意对象，这完全取决于函数的调用方式，带来灵活性也带来困惑。js“超级”迟绑定（ very late binding）使得函数可以对this高度复用。通过this可取得它们所属对象的上下文的方法称为公共方法。使用this关键字在面向对象语言中多数情况下是为了避免命名冲突。总的来说，JavaScript 中函数的调用有以上几种方式：作为对象方法调用，作为函数调用，作为构造函数调用，和使用 apply 或 call 调用。JavaScript 中的函数既可以被当作普通函数执行，也可以作为对象的方法执行，这是导致 this 含义如此丰富的主要原因。
函数的执行环境
JavaScript 中的函数既可以被当作普通函数执行，也可以作为对象的方法执行，这是导致 this 含义如此丰富的主要原因。一个函数被执行时，会创建一个执行环境（ExecutionContext），函数的所有的行为均发生在此执行环境中，构建该执行环境时，JavaScript 首先会创建 arguments变量，其中包含调用函数时传入的参数。接下来创建作用域链。然后初始化变量，首先初始化函数的形参表，值为 arguments变量中对应的值，如果 arguments变量中没有对应值，则该形参初始化为 undefined。如果该函数中含有内部函数，则初始化这些内部函数。如果没有，继续初始化该函数内定义的局部变量，需要注意的是此时这些变量初始化为 undefined，其赋值操作在执行环境（ExecutionContext）创建成功后，函数执行时才会执行，这点对于我们理解 JavaScript 中的变量作用域非常重要，鉴于篇幅，我们先不在这里讨论这个话题。最后为 this变量赋值，如前所述，会根据函数调用方式的不同，赋给 this全局对象，当前对象等。至此函数的执行环境（ExecutionContext）创建成功，函数开始逐行执行，所需变量均从之前构建好的执行环境（ExecutionContext）中读取。
本文是综合了互联网多篇文章结论之后亲测的结论，目的也在于细化自己的知识体系，并进而更深刻的理解js的内核实现。经过此番梳理，对this的灵活指向已经有了一个比较清晰的认识，不过还需在实际的工程中不断运用以达到完全掌握。不过经过此一番，没必要死记硬背以上多种场景，若需使用的时候，在对印位置打印出来看看不就知道了？