js中this的知识点

1.this始终指向调用它的对象,但是难点就是判断这个对象是哪个；
(1)

function a(){
    console.log(this===window)
}
a();
//true

(2)

function a(){
    console.log(this===window)
}
function b(){
    a();
}
b();
//true

(1)函数内部普通方式下，调用该段代码的直接对象是全局对象，即”window” ；(2)处虽然是函数，但是调用其的仍然是”window“(不要弄混了，函数虽然是对象，但是调用它的是另一个对象)；没有实例引用所以还是指向window.

function a(){
return function(){
    console.log(this===window);}
}
var b = a();
b();
//true

即使是return方式，this依然指向window.

function a(){
var b = function(){
    console.log(this===window);
    }
    b();
}
a();
//true

函数内部嵌套，但是都指向window.原因是从最外层函数开始每层都是被window调用，即使你嵌套一千层，调用各个函数的都是’window’对象。
(3)

var test = function(){
  alert(this === window);
 }
new test();
//false

这里test被看作构造函数，并创建了一个空的实例，所以this指向调用构造函数的这个实例
(4)

var test ={
  'a':1,
  'b':function(){
   alert(this === test)
  }
 }
test.b();
//true

这里是对象引用的方式，而不是函数，’b’元素是一个函数，所以this指向的是对象test.

var test ={
  'a':1,
  'b':{
      'c':function(){
       alert(this === test)
       }
  }
 }
test.b.c();
//false

this指向的是调用它的对象，所以这是是test.b调用的，this应该指向test.b
(5) call与apply

var test = function(){
  alert(this === test1);
 }
var test1 = {
}
test.apply(test1);
//true

call，apply都是test1调用test的，所以自然this会指向test1.
(6)原型

var test = function(){
 }
 var my = function(){
  this.a = function(){
   alert(this === mytest2);
  }
 }
 var mytest = new my();
 test.prototype = mytest;
 var mytest2 = new test();
 mytest2.a();

结果是true,首先this指向了实例mytest,然后被原型继承给test,原型继承，改变this指向，这样this就会指向test,最后又指向了test()的实例mytest2.