this指向及改变this指向的方法

this的指向在函数定义时是确定不了的，只有在函数执行时才能确定，this最终指向调用它的对象。

this在js中主要有四种用法：

1、作为普通函数使用

2、作为对象方法来使用

3、call和apply

4、作为构造函数来使用

1、作为普通函数使用

var name='window';
function s(){
    var name='myself';
    console.log(this.name);//window
}
s();

2、作为对象方法来使用

var name='window';
var obj={
    name:'obj',
    sayName:function(){
        console.log(this.name);
    }
}
obj.sayName();//obj;

这个很简单，this指向自己,所以this.name就用hello;

（在全局里面this指向window,在某个对象里面this指向该对象，在闭包里面this指向window）

var user="the Window";
var box={
  user:'the box',
  getThis:function(){
    return this.user;
  },
  getThis2:function(){
    return function (){
      return this.user;
    }
  }
};
alert(this.user);//the Window
alert(box.getThis());//the box
alert(box.getThis2()());//the Window （由于使用了闭包，这里的this指向window）
alert(box.getThis2().call(box));//the box 对象冒充（这里的this指向box对象）

3、call和apply

所有函数对象都有两个方法：apply和call，这两个方法可以让我们构建一个参数数组传递给调用函数，也允许我们改变this值。

使sayName中的this指向b,改变this的指向
var name='window';
var obj={
    name:'obj',
    sayName:function(){
        console.log(this.name);
    }
}
var b={name:'abcd'};
//改变this指向
var newobj=obj.sayName;
newobj();//将this指向全局

newobj.call(b);//abcd   将this指向b   改变this的指向并且执行调用函数

4、作为构造函数来使用

function test(){
    this.name=1;
}
var myobj=new test();
console.log(myobj.name);

new操作符具体干了什么呢?

var Func=function(){  }; 

var f=new Func ();  

new共经过了4几个阶段：

1：创建一个空对象 var obj=new Object(); 

2：设置原型链，让空对象的__proto__指向函数的原型prototype。  obj.__proto__= Func.prototype;  

3：让Func()中的this指向空对象obj，并执行Func(）的函数体；var result =Func.call(obj);  

4：判断Func(）的返回值类型

　　如果是值类型，返回obj。如果是引用类型，就返回这个引用类型的对象。

　　使用new来创建对象时，如果return的是非对象（数字、字符串、布尔类型、null等）或没有返回值时会忽略该返回值，返回的是新创建的对象  ；如果return的是对象，则返回该对象。

（1）返回的是非对象
function Person(name){
    this.name=name;
    return name;
}
var p=new Person('tom');
console.log(p);//Person {name: "tom"}
（2）返回的是对象
function Person(name){
    this.name=name;
    return {'name1':name};
}
var p=new Person('tom');
console.log(p);//{name1: "tom"}    

构造函数与普通函数的区别

 构造函数也是一个普通函数，创建方式和普通函数一样。

（1）调用方式：构造函数在调用时使用new关键字   new Fun()；普通函数调用则直接调用fun()

（2）this指向：在构造函数内部，this指向的是构造出来的新对象；在普通函数内部this指向window全局对象

（3）return返回值：构造函数会默认返回this，也就是新的实例对象；普通函数如果没有return,返回undefined，如果使用了return，那么返回值会根据return的类型而判断。

练习题

在执行person1.sayName()时，this指向person1对象

在执行person2.sayName()时，sayName()方法并没有执行，而是将sayName()赋值给fun变量，fun()是普通函数调用模式，this指向window，所以输出全局name

 

执行console.log(b.n)时，b对象有自己的属性n值

执行console.log(c.n)时，c对象没有自己的属性n值，会向上查找，找的A对象中的属性n值

 

var getColor=test.getColor相当于把方法函数赋值给全局变量，

故getColor()中的this指向window

二、改变this指向的方式

以下属于函数的方法

改变this的指向并且执行调用函数

（1）通过一个对象的方法来定义函数，并用该对象调用方法。

var name='window';
var obj={
    name:'obj',
    sayName:function(){
        console.log(this.name);
    }
}
var b={};
b.x='is o'
b.fun=obj.sayName;
b.fun();

（2）call()和apply()

　　call()方法存在于Function的原型上，Function.prototype.call()，因此每个函数都可以通过原型链继承下来。属于函数的方法，只有函数对象可以调用

相同点：两个方法产生的作用是完全一样的，都用来改变当前函数调用的对象。

不同点：调用的参数不同，比较精辟的总结：

　　　　foo.call(this,arg1,arg2,arg3) == foo.apply(this, arguments)==this.foo(arg1, arg2, arg3)

1.call的使用

　　call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。

window.color="red";
var o={
　　color:"blue"
};
function sayColor(){
　　console.log(this.color);
}
sayColor();//指向window
sayColor.call(this) ; //指向自己
sayColor.call(window); //red
sayColor.call(o); //blue

解析：最后一个之所以输出的是blue，是因为call()方法的第一个参数指的是在其中运行函数的作用域，所以在sayColor.call(o)中，它把函数的作用域定在了对象o中，所以函数sayColor()中的this.color即为o.color,因此输出的是对象o的color的值bule. 

2.apply()

　　apply与call的功能几乎一样，第一个参数意义都一样，只是第二个参数有点不同apply传入的是一个参数数组，也就是将多个参数组合成为一个数组传入，call从第二个参数开始，依次传值给调用函数的参数 

 call、apply与bind的区别：前两个可以自动执行，bind只创建一个新的函数，不会自动执行，需要手动调用。

call()会比apply()执行速度快，主要是因为在apply方法中，对数组参数有多次判断，执行步骤比call多。

（3）bind()

bind()会创建一个函数的实例，其this值会被绑定到传给bind()函数的值。如

var color='red';
var o1={
    color:'blue'
};
var o2={
    color:'yellow'
};
function sayColor(){
    console.log(this.color);
}
//call()自动执行
sayColor.call(o1);//blue

//bind()需手动执行
var say=sayColor.bind(o2);
say();//yellow

bind()除了改变函数this指向的功能，还有柯里化的功能，即把一个函数拆成多个单元。

柯里化就是把一个多参数的函数，转换为单参数函数。只传递给函数一部分参数来调用它，让它返回一个函数去处理剩下的参数。

function add(a,b,c){
    console.log(a+b+c);
}

var func=add.bind(undefined,100);//第一个参数为undefined、null指不需要改变this
func(1,2);//103    绑定时传入一个参数100，在调用时传入第二个和第三个参数

var func2=func.bind(undefined,200);
func2(10);//310      之前绑定a=100,所以200绑定到b上

为什么要使用柯里化呢？

比如需要写一个获取一套配置的函数，不同页面下的配置可能是不同的，在同一模块下，其中有些参数是相同的，不同页面获取时只需要传入otherOptions即可，把一个函数拆分成子函数，使代码重用。

bind与new

function foo(){
    this.b=100;
    return this.a;
}
var func=foo.bind({a:1});
console.log(func());//1
console.log(new func());//{b:100}

使用new 函数时，函数中的return除非是对象，否则会把this作为返回值，并且this会被初始化一个默认的空对象，对象的原型就是foo.prototype，所以new一个对象时，即使方法以bind了一个对象，this仍指向原函数。

拓展：

1、手写bind()函数 

考虑到构造函数的情况：

Function.prototype.bind2=function(context){
    var self=this;
    if(typeof this !='function'){//要求调用bind的必须是函数
        throw new Error("Function.prototype.bind")
    }
                    
    var oArgs=Array.prototype.slice.call(arguments,1);
                    
    var fNOP=function(){}
    var fBound=function(){
        var iArgs=Array.prototype.slice.call(arguments);
        var args=oArgs.concat(iArgs);
        //当作为普通函数时，this指向window,self指向绑定函数，此时结果为false;当结果为false时，令this指向context
        //如果bind后的新函数要做new操作，那么this指向新函数，所以this instanceof self==true
        return self.apply(this instanceof fBound?this:context,args);
    }
    fNOP.prototype=this.prototype;
    fBound.prototype=new fNOP();//用于构造函数时，使fBound是构造函数的实例
    return fBound;
}

function fun(name){
    this.name=name
    return this.name;
}
var obj={
    name:'obj'
}
var f=fun.bind2(obj,'an');
console.log(new f());

 知识点：

（1） Array.prototype.slice.call(arguments)能够将类数组对象转换为数组。

 （2）Array.prototype.slice.call(arguments,1);//截取，获取外部函数的第一个参数之后的所有参数,参数1表示被返回的数组包含从第二个参数开始的所有参数，即去除函数自己的方法名

2、实现一个call()函数

1.将函数对象设置为对象的属性
2.执行这个函数
3.删除这个函数
Function.prototype.myCall=function(context){
    //判断是否传入指定的对象
    context=context||window;
    //把调用的函数添加到对象中
    context.fn=this;
    var arg=[...arguments].slice(1);
    //执行函数
    let res=context.fn(arg);
     //执行函数后从对象中删除函数
　 delete context.fn;
    return res;
}
//执行过程类似：obj.f=fun;obj.f();

3、实现一个apply()函数

Function.prototype.myApply=function(context,arr){
    context=context||window;
    context.fn=this;
    if(arr&&!Array.isArray(arr)){
        throw new TypeError('not funciton');
        return;
    }
    let res=context.fn(arr);
        delete context.fn;
    return res;
}

4、模拟new的实现过程

//把构造函数作为第一个参数传入
function objectFactory(){
    var obj=new Object();
    //取出第一个参数，就是我们要传入的构造函数，因为shift会改变原数组，所以arguments会被去除第一个参数
    var fun=Array.prototype.shift.call(arguments);
    //将obj的原型指向构造函数，这样obj就可以访问到构造函数原型中的属性了
    obj.__proto__=fun.prototype;
    //改变构造函数this的指向
    var res=fun.apply(obj,arguments);
    return typeof res=='object'?res:obj;//判断函数的返回值，如果返回值为对象，则返回这个对象，否则返回新创建的对象
}
                
var q=objectFactory(func,'an');

5、函数柯里化

var newArgs=[];
function curry(fn,args){
    var length=fn.length;//指fn总共的参数个数
    var args=args||[];
    return function(){
                    newArgs=args.concat(Array.prototype.slice.call(arguments));
        if(newArgs.length<length){
            return curry.call(this,fn,newArgs);
        }
        else{
            return fn.apply(this,newArgs);
        }
    }
}
        
function multiFn(a,b,c){
    return a*b*c;
    
var multi=curry(multiFn);
console.log(multi(2,3)(4));
console.log(multi(2)(3)(4));

三、箭头函数中的this

由于箭头函数不绑定this，他会捕获其所在（即定义位置）上下文的this值，作为自己的this。

所以call()、apply()、bind()方法对于箭头函数来说只是传入参数，对他的this毫无影响。