this指向练习题
1.代码输出结果
function foo() {
console.log( this.a );
}
function doFoo() {
foo();
}
var obj = {
a: 1,
doFoo: doFoo
};
var a = 2;
obj.doFoo()
//obj.doFoo()后doFoo里的this指向obj，但是doFoo里调用foo()为普通调用，因此foo()里的this还是window，输出wei2
2.代码输出结果
var a = 10
var obj = {
a: 20,
say: () => {
console.log(this.a)
}
}
obj.say()//箭头函数中的this
var anotherObj = { a: 30 }
obj.say.apply(anotherObj)
obj.say为箭头函数，apply不会改变this指向，而obj.say为箭头函数，且外部没有函数，this为window，因此结果为10
3.代码输出结果
function a() {
console.log(this);
}
a.call(null);
4.代码输出结果
var obj = {
name : 'cuggz',
fun : function(){
console.log(this.name);
}
}
obj.fun()
new obj.fun()
obj.fun()this指向obj因为打印输出cuggz;new obj.fun()中的this指向这个新new的对象，因此为undefined
6.代码输出结果
var obj = {
say: function() {
var f1 = () => {
console.log("1111", this);
}
f1();
},
pro: {
getPro:() => {
console.log(this);
}
}
}
var o = obj.say;
o();
obj.say();
obj.pro.getPro();
o()直接调用，this指向window，f1里的this取决于外层函数的this即为window；obj.say()函数this指向obj，因此f1里的this也为obj；obj.pro.getPro为箭头函数，且该函数外层没有函数，因此getPro里的this为window
7.代码输出结果
var myObject = {
foo: "bar",
func: function() {
var self = this;
console.log(this.foo);
console.log(self.foo);
(function() {
console.log(this.foo);
console.log(self.foo);
}());
}
};
myObject.func();
self与this都指向myObject，因此前两个输出都是bar，后面function为立即调用，可以理解为普通调用的方式，this为window，因此输出为undefined与bar
8.代码输出问题
window.number = 2;
var obj = {
number: 3,
db1: (function(){
console.log(this);
this.number *= 4;
return function(){
console.log(this);
this.number *= 5;
}
})()
}
var db1 = obj.db1;
db1();
obj.db1();
console.log(obj.number);
console.log(window.number);
ob执.db1运行为立即执行函数，立即执行函数由obj执行调用，因此this指向obj，返回的函数为标准函数；db1()执行结果this为winodw，10
obj.db1()this执行obj，结果为345
9.代码输出结果
var length = 10;
function fn() {
console.log(this.length);
}
var obj = {
length: 5,
method: function(fn) {
fn();
arguments[0]();
}
};
obj.method(fn, 1);
执行obj.method时函数里的this为obj，由于fn()为普通调用，因此fn里的this为windows，结果为10； 第二次执行arguments[0]，this指向将其当方法调用的对象，因此this指向arguments，this.length为2
10.代码输出结果
var a = 1;
function printA(){
console.log(this.a);
}
var obj={
a:2,
foo:printA,
bar:function(){
printA();
}
}
obj.foo();
obj.bar();
var foo = obj.foo;
foo();
obj.foo()对象调用，this为obj，输出为2 obj.bar()对象调用，但是printA()直接调用，this为window，结果为1 foo()直接调用，this为window，结果为1
11.代码输出结果
var x = 3;
var y = 4;
var obj = {
x: 1,
y: 6,
getX: function() {
var x = 5;
return function() {
return this.x;
}();
},
getY: function() {
var y = 7;
return this.y;
}
}
console.log(obj.getX())
console.log(obj.getY())
obj.getY():对象调用，this为obj，为6 obj.getX()：对象调用，getX()内的this为obj,并且window.x为5；返回立即调用函数，this指向window，结果为3，var中声明的变量x仅存在于函数getX内
12.代码输出结果
var a = 10;
var obt = {
a: 20,
fn: function(){
var a = 30;
console.log(this.a)
}
}
obt.fn();
obt.fn.call();
(obt.fn)();
obt.fn()this指向obt，输出为20；call第一个参数为null，绑定在windows上，因此结果为10；~~(obt.fn)()等同于普通调用函数，fn中声明的变量a为函数作用域！！！因此结果是10~~添加括号的作用是改变表达式的运算顺序，这里加不加括号都没有影响，因此打印结果为20
13.代码输出结果
function a(xx){
this.x = xx;
return this
};
var x = a(5);
var y = a(6);
console.log(x.x)
console.log(y.x)
var x = a(5)，这一步先是给window添加属性x为undefined，然后在函数a(5)内，将x修改为5后，返回this，因此x从undefined变为5又变为this本身，因此x为window，window中没有x属性：var x = this y为window，y.x即为window.x为6，因此结果为6
14.代码输出结果
function foo(something){
this.a = something
}
var obj1 = {
foo: foo
}
var obj2 = {}
obj1.foo(2);
console.log(obj1.a);
obj1.foo.call(obj2, 3);
console.log(obj2.a);
var bar = new obj1.foo(4)
console.log(obj1.a);
console.log(bar.a);
obj1.foo(2)中，this指向obj1，因此obj1.a = 2， obj1.foo.call(obj2,3)在运行foo时this指向obj2，因此obj2.a = 3 new obj1.foo(4)时,this指向bar，因此bar.a = 4，因此obj1.a为前面的2，bar.a为4
15.代码输出结果
function foo(something){
this.a = something
}
var obj1 = {}
var bar = foo.bind(obj1);
bar(2);
console.log(obj1.a); // 2
var baz = new bar(3);
console.log(obj1.a); // 2
console.log(baz.a); // 3
这道题目和上面题目差不多，主要都是考察this绑定的优先级。记住以下结论即可：this绑定的优先级：new绑定 > 显式绑定 > 隐式绑定 > 默认绑定。
