一、this的绑定规则
1. 默认绑定
什么情况下使用默认绑定呢?独立函数调用。
独立的函数调用我们可以理解成函数没有被绑定到某个对象上进行调用;
案例一:普通函数调用
该函数直接被调用,并没有进行任何的对象关联;这种独立的函数调用会使用默认绑定,通常默认绑定时,函数中的this指向全局对象(window);
function foo() {
console.log(this); // window
}
foo();
案例二:函数调用链(一个函数又调用另外一个函数)
所有的函数调用都没有被绑定到某个对象上;
// 案例二:
function test1() {
console.log(this); // window
test2();
}
function test2() {
console.log(this); // window
test3()
}
function test3() {
console.log(this); // window
}
test1();
案例三:将函数作为参数,传入到另一个函数中
function foo(func) {
func()
}
function bar() {
console.log(this); // window
}
foo(bar);
我们对案例进行一些修改,考虑一下打印结果是否会发生变化:
这里的结果依然是window,为什么呢?原因非常简单,在真正函数调用的位置,并没有进行任何的对象绑定,只是一个独立函数的调用
function foo(func) {
func()
}
var obj = {
name: "why",
bar: function() {
console.log(this); // window
}
}
foo(obj.bar);
2. 隐式绑定
另外一种比较常见的调用方式是通过某个对象进行调用的:
也就是它的调用位置中,是通过某个对象发起的函数调用。
案例一:通过对象调用函数
foo的调用位置是obj.foo()方式进行调用的;
那么foo调用时this会隐式的被绑定到obj对象上
function foo() {
console.log(this); // obj对象
}
var obj = {
name: "why",
foo: foo
}
obj.foo();
案例二:案例一的变化
我们通过obj2又引用了obj1对象,再通过obj1对象调用foo函数;
那么foo调用的位置上其实还是obj1被绑定了this;
function foo() {
console.log(this); // obj对象
}
var obj1 = {
name: "obj1",
foo: foo
}
var obj2 = {
name: "obj2",
obj1: obj1
}
obj2.obj1.foo();
案例三:隐式丢失
结果最终是window,为什么是window呢?
因为foo最终被调用的位置是bar,而bar在进行调用时没有绑定任何的对象,也就没有形成隐式绑定;
相当于是一种默认绑定;
function foo() {
console.log(this);
}
var obj1 = {
name: "obj1",
foo: foo
}
// 讲obj1的foo赋值给bar
var bar = obj1.foo;
bar();
3. 显示绑定
隐式绑定有以下前提条件:
必须在调用的对象内部有一个对函数的引用(比如一个属性);如果没有这样的引用,在进行调用时,会报找不到该函数的错误;正是通过这个引用,间接的将this绑定到了这个对象上;
如果我们不希望在 对象内部 包含这个函数的引用,同时又希望在这个对象上进行强制调用,该怎么做呢?
JavaScript所有的函数都可以使用call和apply方法(这个和Prototype有关)。它们两个的区别这里不再展开;
其实非常简单,第一个参数是相同的,后面的参数,apply为数组,call为参数列表;这两个函数的第一个参数都要求是一个对象,这个对象的作用是什么呢?就是给this准备的。
在调用这个函数时,会将this绑定到这个传入的对象上。因为上面的过程,我们明确的绑定了this指向的对象,所以称之为 显示绑定。
call、apply
通过call或者apply绑定this对象,显示绑定后,this就会明确的指向绑定的对象
function foo() {
console.log(this);
}
foo.call(window); // window
foo.call({name: "why"}); // {name: "why"}
foo.call(123); // Number对象,存放时123
bind函数
如果我们希望一个函数总是显示的绑定到一个对象上,可以怎么做呢?
方案一:自己手写一个辅助函数(了解)
我们手动写了一个bind的辅助函数,这个辅助函数的目的是在执行foo时,总是让它的this绑定到obj对象上
function foo() {
console.log(this);
}
var obj = {
name: "why"
}
function bind(func, obj) {
return function() {
return func.apply(obj, arguments);
}
}
var bar = bind(foo, obj);
bar(); // obj对象
bar(); // obj对象
bar(); // obj对象
方案二:使用Function.prototype.bind
function foo() {
console.log(this);
}
var obj = {
name: "why"
}
var bar = foo.bind(obj);
bar(); // obj对象
bar(); // obj对象
bar(); // obj对象
内置函数
有些时候,我们会调用一些JavaScript的内置函数,或者一些第三方库中的内置函数。
这些内置函数会要求我们传入另外一个函数;我们自己并不会显示的调用这些函数,而且JavaScript内部或者第三方库内部会帮助我们执行;
案例一:setTimeout
setTimeout中会传入一个函数,这个函数中的this通常是window
setTimeout(function() {
console.log(this); // window
}, 1000);
为什么这里是window呢?这个和setTimeout源码的内部调用有关;setTimeout内部是通过apply进行绑定的this对象,并且绑定的是全局对象;
案例二:数组的forEach
数组有一个高阶函数forEach,用于函数的遍历:
在forEach中传入的函数打印的也是Window对象;
这是因为默认情况下传入的函数是自动调用函数(默认绑定);
var names = ["abc", "cba", "nba"];
names.forEach(function(item) {
console.log(this); // 三次window
});
new绑定
JavaScript中的函数可以当做一个类的构造函数来使用,也就是使用new关键字。
使用new关键字来调用函数时,会执行如下的操作:
1.创建一个全新的对象;
2.这个新对象会被执行Prototype连接;
3.这个新对象会绑定到函数调用的this上(this的绑定在这个步骤完成);
4.如果函数没有返回其他对象,表达式会返回这个新对象;
// 创建Person
function Person(name) {
console.log(this); // Person {}
this.name = name; // Person {name: "why"}
}
var p = new Person("why");
console.log(p);
优先级总结:
new绑定 > 显示绑定(bind)> 隐式绑定 > 默认绑定
二、this规则之外
1. 忽略显示绑定
如果在显示绑定中,我们传入一个null或者undefined,那么这个显示绑定会被忽略,使用默认规则:
function foo() {
console.log(this);
}
var obj = {
name: "why"
}
foo.call(obj); // obj对象
foo.call(null); // window
foo.call(undefined); // window
var bar = foo.bind(null);
bar(); // window
2. 间接函数引用
另外一种情况,创建一个函数的 间接引用,这种情况使用默认绑定规则。
我们先来看下面的案例结果是什么?
(num2 = num1)的结果是num1的值;
var num1 = 100;
var num2 = 0;
var result = (num2 = num1);
console.log(result); // 100
我们来下面的函数赋值结果:
赋值(obj2.foo = obj1.foo)的结果是foo函数;
foo函数被直接调用,那么是默认绑定;
function foo() {
console.log(this);
}
var obj1 = {
name: "obj1",
foo: foo
};
var obj2 = {
name: "obj2"
}
obj1.foo(); // obj1对象
(obj2.foo = obj1.foo)(); // window
3. ES6箭头函数
在ES6中新增一个非常好用的函数类型:箭头函数
这里不再具体介绍箭头函数的用法,可以自行学习。
箭头函数不使用this的四种标准规则(也就是不绑定this),而是根据外层作用域来决定this。
我们来看一个模拟网络请求的案例:
这里我使用setTimeout来模拟网络请求,请求到数据后如何可以存放到data中呢?
我们需要拿到obj对象,设置data;
但是直接拿到的this是window,我们需要在外层定义:var _this = this
在setTimeout的回调函数中使用_this就代表了obj对象
var obj = {
data: [],
getData: function() {
var _this = this;
setTimeout(function() {
// 模拟获取到的数据
var res = ["abc", "cba", "nba"];
_this.data.push(...res);
}, 1000);
}
}
obj.getData();
上面的代码在ES6之前是我们最常用的方式,从ES6开始,我们会使用箭头函数:
为什么在setTimeout的回调函数中可以直接使用this呢?
因为箭头函数并不绑定this对象,那么this引用就会从上层作用域中找到对应的this
var obj = {
data: [],
getData: function() {
setTimeout(() => {
// 模拟获取到的数据
var res = ["abc", "cba", "nba"];
this.data.push(...res);
}, 1000);
}
}
obj.getData();
思考:如果getData也是一个箭头函数,那么setTimeout中的回调函数中的this指向谁呢?
答案是window;
依然是不断的从上层作用域找,那么找到了全局作用域;
在全局作用域内,this代表的就是window
var obj = {
data: [],
getData: () => {
setTimeout(() => {
console.log(this); // window
}, 1000);
}
}
obj.getData();