JS 之 call（）函数

call(thisArg,arg1,arg2.....)

a.call(b)

b:"喂？是a么，我这有点事儿办不了，你来帮帮我呗？"。

a:"OK，我来了！"。

var g="全局变量";
//构造函数
function A(){
	this.g="构造函数A中的变量";
}
//普通函数
function print(){
	console.log(this.g);
}
print.call(new A());

//输出：构造函数A中的变量

A对象想要打印出它的属性g，但是它没有这个方法，所以求助于print()，看起来好像A有了print方法，有点类似于继承。

实际上，调用print.call(new A())时修改了print()的this指向，使this指向了new A()，于是输出this.g的时候输出了A对象的属性g。

在JS中，这又被称为“对象冒充”。

实现继承

//实现继承
function A(name,price){
	this.name=name;
	this.price=price;
        this.func=function(){
            console.log("A");
        }
}

A.prototype.X="XXX";

function B(name,price,speed){
	A.call(this,name,price);
	this.speed=speed;
}

var a=new A("Good",100);
var b=new B("Master",12000,50);
console.log(a);
console.log(b);

输出：

A {name: "Good", price: 100, func: ƒ}
func: ƒ ()
name: "Good"
price: 100
__proto__:
X: "XXX"
constructor: ƒ A(name,price)
__proto__: Object

B {name: "Master", price: 12000, func: ƒ, speed: 50}
func: ƒ ()
name: "Master"
price: 12000
speed: 50
__proto__:
constructor: ƒ B(name,price,speed)
__proto__: Object

不难看出，B对象上有了A对象的属性和方法，当然仅仅是A对象自身的属性和方法，A对象的原型属性和方法不会被继承。

在非严格模式下，使用call方法调用函数不传入第一个参数，默认this的指向会绑定全局对象，例如上面第一个例子，不传入new A()，则打印出来的则会是全局下的g变量。

在严格模式下，不传入第一个参数，this的值会指向undefined，例如：

'use strict'
var x="xxx";
function show(){
	console.log(this.x);
}
show.call();

Uncaught TypeError: Cannot read property 'x' of undefined
  at show (study.html:12)
    at study.html:14