函数的隐式参数 arguments 和 this

在函数 调用 时，arguments和this会被静默的传递给函数，并可以在函数体内引用它们，借以访问函数相关的一些信息。

其中arguments是一个类数组结构，它保存了调用时传递给函数的所有实参；this是函数执行时的上下文对象, 这个对象有些让人感到困惑的行为。 下面分别对他们进行讨论。

1. arguments

1.1 背景

JavaScript 允许函数在调用时传入的实参个数和函数定义时的形参个数不一致, 比如函数在定义时声明了 n 个参数, 在调用函数时不一定非要传入 n 个参数，例如:

// 1. 定义有一个形参的函数fn()
function fn(arg){}

// 2. 在调用时传入 0 个或 多个参数，并不会报错
fn(); // 传入 0 个参数
fn(1,'a',3); // 传入多个参数
复制代码

1.2 arguments 与 形参的对应关系

arguments是个类数组结构，它存储了函数在调用时传入的所有实参, 通过访问它的 length 属性可以得到其中保存的实参的个数，并可以通过 arguments[n] 按顺序取出传入的每个参数( n=1,2,..,arguments.length-1 )。

参数在arguments中保存的顺序和传入的顺序相同, 同时也和形参声明的顺序相同，例如:

function fn(arg1, arg2, arg3){
    console.log(arg1 === arguments[0]);  // true
    console.log(arg2 === arguments[1]);  // true
    console.log(arg3 === arguments[2]);  // true
}

fn(1,2,3); // 调用
复制代码

当传入的实参多于形参个数时，想要获得多余出的实参，就可以用arguments[n]来获取了, 例如:

// 定义只有一个形参的函数
function fn(arg1){ 
    console.log('length of arguments is:',arguments.length);
    console.log('arguments[0] is:', arguments[0]); // 获取传入的第一个实参, 也就是形参 arg1 的值
    console.log('arguments[1] is:', arguments[1]); // 获取第二个实参的值, 没有形参与其对应
    console.log('arguments[2] is:', arguments[2]); // 获取第二个实参的值, 没有形参与其对应
}

fn(1,2,3); // 传入 3 个实参
// 可以得到实际上传入的实参的个数并取出所有实参
// length of arguments is: 3
// arguments[0] is: 1
// arguments[1] is: 2
// arguments[2] is: 3
复制代码

1.3 arguments 与 形参的值相互对应

在非严格模式下, 修改arguments中的元素值会修改对应的形参值；同样的，修改形参的值也会修改对应的arguments中保存的值。下面的实验可以说明:

function fn(arg1, arg2){
    // 1. 修改arguments元素，对应的形参也会被修改
    arguments[0] = '修改了arguments';
    console.log(arg1); 

    // 2. 修改形参值，对应的arguments也会被修改
    arg2 = '修改了形参值';
    console.log(arguments[1]); 
}

fn(1,2);
// '修改了arguments'
// '修改了形参值'
复制代码

但是，在严格模式下不存在这种情况, 严格模式下的arguments和形参的值之间失去了对应的关系:

'use strict'; // 启用严格模式
function fn(arg1, arg2){
    // 修改arguments元素，对应的形参也会被修改
    arguments[0] = '修改了arguments';
    console.log(arg1);

    // 修改形参值，对应的arguments也会被修改
    arg2 = '修改了形参值';
    console.log(arguments[1]);
}

fn(1,2);
// 1
// 2
复制代码

注意: arguments 的行为和属性虽然很像数组, 但它并不是数组，只是一种类数组结构:

function fn(){
    console.log(typeof arguments);  // object
    console.log(arguments instanceof Array);  // false
}

fn();
复制代码

1.4 为什么要了解 arguments

在ES6中, 可以用灵活性更强的解构的方式(...符号)获得函数调用时传入的实参,而且通过这种方式获得的实参是保存在真正的数组中的，例如:

function fn(...args){ // 通过解构的方式得到实参
    console.log(args instanceof Array);  // args 是真正的数组
    console.log(args);  // 而且 args 中也保存了传入的实参
}

fn(1,2,3);
// true
// Array(3) [1, 2, 3]
复制代码

那么在有了上面这种更加灵活的方式以后，为什么还要了解arguments呢? 原因是在维护老代码的时候可能不得不用到它。

2. 函数上下文: this

在函数调用时, 函数体内也可以访问到 this 参数, 它代表了和函数调用相关联的对象,被称为函数上下文。

this的指向受到函数调用方式的影响, 而函数的调用方式可以分成以下4种:

1. 直接调用, 例如: fn()
2. 作为对象的方法被调用, 例如: obj.fn()
3. 被当做一个构造函数来使用, 例如: new Fn()
4. 通过函数 call() 或者 apply() 调用, 例如: obj.apply(fn) / obj.call(fn)

下面分别讨论以上 4 种调用方式下 this 的指向.

2.1 直接调用一个函数时 this 的指向

有些资料说在直接调用一个函数时, 这个函数的 this 指向 window, 这种说法是片面的, 只有在非严格模式下而且是浏览器环境下才成立, 更准确的说法是:在非严格模式下, this值会指向全局上下文(例如在浏览器中是window, Node.js环境下是global)。而在严格模式下, this 的值是 undefined。实验代码如下:

// 非严格模式
function fn(){
    console.log(this);
}

fn();  // global || Window
复制代码

严格模式下:

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

fn(); // undefined
复制代码

总结: 在直接调用一个函数时, 它的 this 指向分成两种情况: 在非严格模式下指向全局上下文, 在严格模式下指向 undefined .

2.2 被一个对象当做方法调用

当函数被一个对象当成方法调用时, 这个函数的 this 会指向调用它的对象。代码验证如下:

// 定义一个对象
let xm = {
    getThis (){ // 定义一个函数
        return this;  // 这个函数返回自己的 this 指向
    }
}

let thisOfFunc = xm.getThis();  // 通过对象调用函数得到函数的 this 指向
console.log(thisOfFunc === xm); // true, 函数的this指向调用它的对象本身
复制代码

因为这个原因, 对象的属性可以通过this来访问, 如果给 xm 加上一个 name 属性, 则通过 xm.name可以得到这个属性值, 也可以在函数中通过 this.name 得到属性值, 即 this.name 就是 vm.name , 进一步, this===xm 。 实验如下:

let xm = {
    name: '小明', // 给 xm 加一个属性, 可以通过 xm.name 访问到
    getName (){ 
        return this.name; // 返回 this 的指向的 name 属性
    }
}

console.log(xm.name, xm.getName()); // 小明 小明
复制代码

2.3 被作为构造函数来调用时

2.3.1 不要像使用普通函数一样使用构造函数

构造函数本质上是函数, 只是在被 new 操作符调用时一个函数才被称为构造函数。然而话虽如此, 但是由于写出一个构造函数的目的是用他来创建一个对象, 所以还要有一些约定俗成的东西来限制这个概念, 避免把构造函数当成普通函数来使用。例如, 构造函数虽然能被直接调用, 但是不要这样做，因为这是一个普通函数就可以做到的事情，例如:

function Person(name){
    this.name = name;

    return 1; // 不要这样对待构造函数
}

let n = Person();  // 不要这样使用构造函数
复制代码

2.3.2 使用构造函数创建对象时发生了什么

当使用 new 关键字来调用构造函数的最终结果是产生了一个新对象, 而产生新对象的过程如下:

1. 创建一个空对象 {}
2. 将该对象的 prototype 链接到构造函数的 prototype 上
3. 将这个新对象作为 this 的指向
4. 如果这个构造函数没有返回一个引用类型的值, 则将上面构造的新对象返回

上面的内容如果需要完全理解, 还需要了解原型相关的内容。这里只需要关注第3、4步就可以了,即:将this绑定到生成到的新对象上，并将这个新对象返回, 进一步下结论为：使用构造函数时, this 指向生成的对象， 实验结果如下:

function Person(){
    this.getThis = function(){ // 这个函数返回 this
        return this;
    }
}

let p1 = new Person(); // 调用了构造函数并返回了一个新的对象
console.log(p1.getThis() === p1); // true

let p2 = new Person();
console.log(p2.getThis() === p2); //  true
复制代码

2.3.3 结论

从上面的内容可以得到如下的结论: 当函数作为构造函数使用时, this 指向返回的新对象

2.4 通过 call() 或者 apply() 调用时

使用函数 call 和 apply 可以在调用一个函数时指定这个函数的 this 的指向, 语法是:

fn.call(targetThis, arg1, arg2,..., argN)
fn.apply(targetThis, [arg1, arg2,.., argN])

fn: 要调用的函数
targetThis: 要把 fn 的 this 设置到的目标
argument: 要给 fn 传的实参
复制代码

例如定义一个对象如下:

let xm = {
    name: '小明',
    sayName(){
        console.log(this.name);
    }
};

xm.sayName();  // 对象调用函数输出 '小明'
复制代码

上面定义了一个对象, 对象的 name 属性为'小明'; sayName 属性是个函数, 功能是输出对象的 name 属性的值。根据2.2部分可知 sayName 这个函数的 this 指向 xm 对象, this.name 就是 xm.name 。下面定义一个新对象, 并把 xm.sayName 这个函数的 this 指向新定义的对象。

新定义一个对象 xh:

let xh = {
    name: '小红'
};
复制代码

对象 xh 只有 name 属性, 没有 sayName 属性, 如果想让 xh 也使用 sayName 函数来输出自己的名字, 那么就要在调用 sayName 时让它的 this 指向小红, 以达到 this.name 等于 xh.name 的目的。 这个目的就可以通过 call 和 apply 两个函数来实现。 以 call 函数为例来实现这个需求, 只需要这样写就可以了:

xm.sayName.call(xh);  // 小红
xm.sayName.apply(xh);  // 小红
复制代码

其中fn为xm.sayName; targetThis为xh, 这是因为targetThis的指向就是xh, 此结论可以由 2.2部分 的内容得到。

2.4.1 call 和 apply 的区别

call 和 apply 的区别仅仅是要传给fn的参数的形式不同:对于apply,传给fn的参数argument是个数组,数组由所有参数组成;对于call,传给fn的参数argument直接是所有参数的排列, 直接一个个写入就可以。 例如要传给函数fn三个参数: 1、2、3. 则对于 call和apply调用的方法分别是:

fn.call(targetThis, 1, 2, 3); // 把 1,2,3直接传入
fn.apply(targetThis, [1,2,3]); // 把1,2,3合成数组后作为参数
复制代码

2.5 箭头函数 和 bind 函数

箭头函数和bind函数对于this的处理与普通函数不同, 要单独拿出来说。

2.5.1 箭头函数

与传统函数不同, 箭头函数本身不包含this, 它的 this 继承自它定义时的作用域链的上一层。而且箭头函数不能作为构造函数，它也没有文章 第1部分 所说的arguments属性。

下面用一个例子引出箭头函数中this的来源:

function Person(){
    this.age = 24;
  
    setTimeout(function(){
      console.log(this.age); // undefined
      console.log(this === window); // true
    }, 1000);
  }
  
  var p = new Person(); // 创建一个实例的时候就立即执行了定时器
复制代码

可以看到, 在定时器内定义的普通匿名函数无法访问到 Person 的 age 属性, 这是因为setTimeout是个全局函数, 它的内部的this指向的是window, 而 window 上没有 age 这个属性, 所以就得到了 undefined。 从下面 this === window 为 true 也说明了匿名函数中this指向的是window。

将普通的函数换成箭头函数之后可以看到如下结果:

function Person(){
this.age = 24;

setTimeout(() => {
    console.log(this.age); // 24
    console.log(this === p); // true
}, 1000);
}
  
var p = new Person();
复制代码

由上面的代码可以看出箭头函数内的 this 指向实例 p, 即它的 this 指向的是定义时候的作用域链的上一层。

说明: 这个例子仅用来引出箭头函数的this指向的来源, 不要像这样使用构造函数。

2.5.2 bind函数

bind 函数的作用是根据一个旧函数而创建一个新函数，语法为 newFn = oldFn.bind(thisTarget) 。它会将旧函数复制一份作为新函数, 然后将新函数的this永远绑定到thisTarget指向的上下文中, 然后返回这个新函数, 以后每次调用这个新函数时, 无论用什么方法都无法改变这个新函数的 this 指向。例如:

// 创建一个对象有 name 和 sayName 属性
let p1 = {
    name: 'P1',
    sayName(){ 
        console.log(this.name); // 访问函数指向的 this 的 name 属性
    }
}
p1.sayName(); // P1

// 创建一个对象 p2, 并把这个对象作为bind函数绑定的this
let p2 = {
    name: 'P2'
}
// 将p1的 sayName 函数的 this 绑定到 p2 上, 生成新函数 sayP2Name 并返回
let sayP2Name = p1.sayName.bind(p2); 

// 由于此时 sayP2Name 的内部 this 已经绑定了 p2, 
// 所以即使是按 文章2.1部分 所说的直接调用 sayP2Name, 它的 this 也是指向 p2 的, 并不是指向全局上下文或者 undefined
sayP2Name();  // P2

// 定义新对象, 尝试将 sayP2Name 的 this 指向到 p3 上
let p3 = {
    name: 'P3'
}
// 尝试使用 call和apply 函数来将 sayP2Name 函数的 this 指向p3,
// 但是由于 sayP2Name 函数的this 已经被bind函数永远绑定到p2上了, 所以this.name仍然是p2.name
sayP2Name.call(p3); // P2
sayP2Name.apply(p3); // P2
复制代码

通过以上内容可知一旦通过 bind 函数绑定了 this, 就再也无法改变 this 的指向了.