JavaScript中的this

解析器在调用函数每次都会向函数内部传递进一个隐含的参数，这个隐含的参数就是this，this指向的是一个对象，这个对象我们称为函数执行的 上下文对象，根据函数的调用方式的不同，this会指向不同的对象

以函数的形式调用时，this永远都是window

以方法的形式调用时，this就是调用方法的那个对象

以构造函数的形式调用时，this就是新创建的对象

使用call和apply调用时，this是指定的那个对象
  	// 定义一个函数
function fun(){
       console.log(this.name);
   }

   //创建一个对象
   var obj = {
       name:"孙悟空",
       sayName:fun
   };

   var obj2 = {
       name:"沙和尚",
       sayName:fun
   };

   var name = "全局的name属性";
   //以函数形式调用，this是window
   fun();

   //以方法的形式调用，this是调用方法的对象
   obj.sayName();
   obj2.sayName();

在函数默认使用的时候，它属于的是windons下的一个函数，因此this就是windons而如果采用对象调用的时候，那么this就是对象

apply和call

通过apply和call可以改变this的指向

apply和call的使用方法

apply的使用语法

函数名字.apply(对象,[参数1,参数2,…]);
方法名字.apply(对象,[参数1,参数2,…]);

call的使用语法

函数名字.call(对象,参数1,参数2,…);

方法名字.call(对象,参数1,参数2,…);

其作用都是改变this的指向，不同的地方就是参数传递的方式是不一样的

只要是想使用别的对象的方法,并且希望这个方法是当前对象的,那么就可以使用apply或者是call的方法改变this的指向

方法一：

function f1(x, y) {
  console.log("这个函数是" + this + "对象的一个方法:" + (x + y) + this.sex);
}
//    //obj是一个对象
var obj = {
  age: 10,
  sex: "男",
  fn: f1
};

f1(10, 20)	// this 是 window

f1.apply(obj, [10, 20]);	// this 是 obj
f1.call(obj, 10, 20);	// this 是 obj
obj.fn(1, 2)	// this 是 obj

本来f1函数是window对象的,但是传入obj之后,f1函数此时就是obj对象的

方法二：

   function Person(age, sex) {
     this.age = age;
     this.sex = sex;
   }
   // 通过原型添加方法
   Person.prototype.sayHi = function (x, y) {
     console.log(this.constructor.name + "您好:" + this.sex);
     return 1000;
   };
   var per = new Person(10, "男");
   per.sayHi();	// 	Person您好:男
//	提供新的构造函数
   function Student(name, sex) {
     this.name = name;
     this.sex = sex;
   }
   var stu = new Student("小明", "人妖");
   var r1 = per.sayHi.apply(stu, [10, 20]);	// Student您好:人妖
   var r2 = per.sayHi.call(stu, 10, 20);	// Student您好:人妖

apply和call方法实际上并不在函数这个实例对象中,而是在Function的prototype中

bind

bind方法是复制的意思,参数可以在复制的时候传进去,也可以在复制之后调用的时候传入进去

与apply和cal不同的是：

apply和call是调用的时候改变this指向
bind方法,是赋值一份的时候,改变了this的指向

使用的语法:

函数名字.bind(对象,参数1,参数2,...);——>返回值是复制之后的这个函数
方法名字.bind(对象,参数1,参数2,...);——>返回值是复制之后的这个方法

方法一：

   function f1(x, y) {
     console.log((x + y) + ":=====>" + this.constructor.name);
   }
   var ff = f1.bind(null);	
   ff(10, 20);	// 30:=====>Window
// 构建新的对象
   function Person() {
     this.age = 1000;
   }
   Person.prototype.eat = function () {
     console.log("吃");
   };
// 实例化对象
   var per = new Person();

   var ff = f1.bind(per, 10, 20);
   ff();  // 30:=====>Person

方法二：

function Person(age) {
  this.age = age;
}
Person.prototype.play = function () {
  console.log(this.constructor.name + "====>" + this.age);
};

function Student(age) {
  this.age = age;
}
var per = new Person(10);
var stu = new Student(20);
//复制了一份
var ff = per.play.bind(stu);
ff();	// Student====>20

bind的案例使用

//通过对象,调用方法,产生随机数
function ShowRandom(num) {
  // 指定随机数产生范围
  this.num = num
}
//添加原型方法
ShowRandom.prototype.show1 = function () {
  //改变了定时器中的this的指向了,本来应该是window,现在是实例对象了
  window.setInterval(this.show2.bind(this), 1000);
};
//添加原型方法
ShowRandom.prototype.show2 = function () {
  // 动态生成随机数
  this.number = parseInt(Math.random() * this.num + 1);
  //显示随机数--
  console.log(this.number);
};
//实例对象,制定随机数范围
var sr = new ShowRandom(10);
//调用方法,输出随机数字
//调用这个方法一次,可以不停的产生随机数字
sr.show1();

通过在window.setInterval中使用bind()改变this的指向，从而调用了show2函数