06.Javascript——入门this的用法(难点)

this 的指向

this 是 js 中定义的关键字，它自动定义于每个函数域内，可是它的指向却让人很迷惑。在实际应用中，this 的指向大体能够分为如下四种状况。

1.做为普通函数调用

当函数做为一个普通函数被调用，this 指向全局对象。在浏览器里，全局对象就是 window。

window.name = 'linxin';
function getName(){
    console.log(this.name);
}
getName();                   // linxin

能够看出，此时 this 指向了全局对象 window。 在ECMAScript5的严格模式下，这种状况 this 已经被规定不会指向全局对象了，而是 undefined。

'use strict';
function fun(){
    console.log(this);
}
fun();   

2.做为对象的方法调用

当函数做为一个对象里的方法被调用，this 指向该对象

var obj = {
    name : 'linxin',
    getName : function(){
        console.log(this.name);
    }
}

obj.getName();              // linxin

若是把对象的方法赋值给一个变量，再调用这个变量：

var obj = {
    fun1 : function(){
        console.log(this);
    }
}
var fun2 = obj.fun1;
fun2();                     // window

此时调用 fun2 方法 输出了 window 对象，说明此时 this 指向了全局对象。给 fun2 赋值，实际上是至关于：

var fun2 = function(){
    console.log(this);
}

能够看出，此时的 this 已经跟 obj 没有任何关系了。这时 fun2 是做为普通函数调用。

3.做为构造函数调用

js中没有类，可是能够从构造器中建立对象，并提供了 new 运算符来进行调用该构造器。构造器的外表跟普通函数同样，大部分的函数均可以当作构造器使用。当构造函数被调用时，this 指向了该构造函数实例化出来的对象。

var Person = function(){
    this.name = 'linxin';
}
var obj = new Person();
console.log(obj.name);      // linxin

若是构造函数显式的返回一个对象，那么 this 则会指向该对象。

var Person = function(){
    this.name = 'linxin';
    return {
        name : 'linshuai'
    }
}
var obj = new Person();
console.log(obj.name);      // linshuai

若是该函数不用 new 调用，看成普通函数执行，那么 this 依然指向全局对象。

4.call() 或 apply() 调用

经过调用函数的 call() 或 apply() 方法可动态的改变 this 的指向。

var obj1 = {
    name : 'linxin',
    getName : function(){
        console.log(this.name);
    }
}
var obj2 = {
    name : 'linshuai'
}

obj1.getName();             // linxin
obj1.getName.call(obj2);    // linshuai
obj1.getName.apply(obj2);   // linshuai

apply 和 call 的区别

ECMAScript 规范给全部函数都定义了 call 与 apply 两个方法，它们的应用很是普遍，它们的做用也是如出一辙，只是传参的形式有区别而已。

apply( )

apply 方法传入两个参数：一个是做为函数上下文的对象，另一个是做为函数参数所组成的数组。

var obj = {
    name : 'linxin'
}

function func(firstName, lastName){
    console.log(firstName + ' ' + this.name + ' ' + lastName);
}

func.apply(obj, ['A', 'B']);    // A linxin B

能够看到，obj 是做为函数上下文的对象，函数 func 中 this 指向了 obj 这个对象。参数 A 和 B 是放在数组中传入 func 函数，分别对应 func 参数的列表元素。

call( )

call 方法第一个参数也是做为函数上下文的对象，可是后面传入的是一个参数列表，而不是单个数组。

var obj = {
    name: 'linxin'
}

function func(firstName, lastName) {
    console.log(firstName + ' ' + this.name + ' ' + lastName);
}

func.call(obj, 'C', 'D');       // C linxin D

对比 apply 咱们能够看到区别，C 和 D 是做为单独的参数传给 func 函数，而不是放到数组中。

对于何时该用什么方法，其实不用纠结。若是你的参数原本就存在一个数组中，那天然就用 apply，若是参数比较散乱相互之间没什么关联，就用 call。

apply 和 call 的用法

1.改变 this 指向

var obj = {
    name: 'linxin'
}

function func() {
    console.log(this.name);
}

func.call(obj);       // linxin

咱们知道，call 方法的第一个参数是做为函数上下文的对象，这里把 obj 做为参数传给了 func，此时函数里的 this 便指向了 obj 对象。此处 func 函数里其实至关于

 

 

function func() {
    console.log(obj.name);
}

2.借用别的对象的方法

var Person1  = function () {
    this.name = 'linxin';
}
var Person2 = function () {
    this.getname = function () {
        console.log(this.name);
    }
    Person1.call(this);
}
var person = new Person2();
person.getname();       // linxin

从上面咱们看到，Person2 实例化出来的对象 person 经过 getname 方法拿到了 Person1 中的 name。由于在 Person2 中，Person1.call(this) 的做用就是使用 Person1 对象代替 this 对象，那么 Person2 就有了 Person1 中的全部属性和方法了，至关于 Person2 继承了 Person1 的属性和方法。

3.调用函数

apply、call 方法都会使函数当即执行，所以它们也能够用来调用函数。

 

function func() {
    console.log('linxin');
}
func.call();            // linxin

call 和 bind 的区别

在 EcmaScript5 中扩展了叫 bind 的方法，在低版本的 IE 中不兼容。它和 call 很类似，接受的参数有两部分，第一个参数是是做为函数上下文的对象，第二部分参数是个列表，能够接受多个参数。
它们之间的区别有如下两点。

1.bind 发返回值是函数

var obj = {
    name: 'linxin'
}

function func() {
    console.log(this.name);
}

var func1 = func.bind(obj);
func1();                        // linxin

bind 方法不会当即执行，而是返回一个改变了上下文 this 后的函数。而原函数 func 中的 this 并无被改变，依旧指向全局对象 window。

 

2.参数的使用

 

 

function func(a, b, c) {
    console.log(a, b, c);
}
var func1 = func.bind(null,'linxin');

func('A', 'B', 'C');            // A B C
func1('A', 'B', 'C');           // linxin A B
func1('B', 'C');                // linxin B C
func.call(null, 'linxin');      // linxin undefined undefined

call 是把第二个及之后的参数做为 func 方法的实参传进去，而 func1 方法的实参实则是在 bind 中参数的基础上再日后排。

在低版本浏览器没有 bind 方法，咱们也能够本身实现一个。

 

 

if (!Function.prototype.bind) {
        Function.prototype.bind = function () {
            var self = this,                        // 保存原函数
                context = [].shift.call(arguments), // 保存须要绑定的this上下文
                args = [].slice.call(arguments);    // 剩余的参数转为数组
            return function () {                    // 返回一个新函数
                self.apply(context,[].concat.call(args, [].slice.call(arguments)));
            }
        }
    }