参考学习：https://www.cnblogs.com/lisha-better/p/5684844.html
1.普通函数调用（window）
2.作为构造函数调用（）
3.作为方法调用
4.使用call/apply/bind调用
5.ES6箭头函数调用（this取决于包裹箭头函数的第一个普通函数）
**setTimeout()由window对象调用
call()参数为空，this指向window
匿名函数，this也指向window
在事件中，this指向触发这个事件的对象，特殊的是，IE中的attachEvent中的this总是指向全局对象Window
参考学习：https://www.cnblogs.com/chenwenhao/p/6980401.html
https://www.imooc.com/article/20162
https://www.cnblogs.com/humin/p/4556820.html
关于Function和Object创建实例之间的关系
基于原型链继承的链图，对继承有个具体化的概念： （这个是核心继承部分）
上图整体的继承链
js继承：
1.原型链继承
特点；
1.要想为子类新增属性和方法，必须要在new Animal()这样的语句之后执行，不能放到构造器中
2.无法实现多继承
3.来自原型对象的所有属性被所有实例共享
4.创建子类实例时，无法向父类构造函数传参
function SuperType () {
this.property = true;
}
SuperType.prototype.getSuperValue = function() {
return this.property;
};
function SubType() {
this.subproperty = false;
}
//继承SuperType
**SubType.prototype = new SuperType();**
SubType.prototype.getSubValue = function() {
return this.subproperty;
}
var instance =new SubType();
console.log(instance.getSuperValue()); // true
存在问题：
1.包含引用类型值的原型属性会被所有实例共享（修改）,而在构造函数中的基本类型和引用类型属性均不可改变(const附体)
2.创建子类型的实例时，不能向超类的构造函数中传递传递参数
3.无法实现多继承
2.构造函数继承（在子类型构造函数的内部调用超类型）
子类型构造函数中向超类型构造函数传参
问题：函数无法复用
function SuperType() {
this.colors = ["red","blue","green"];
}
function SubType() {
//继承了SuperType --重新创建SuperType构造函数属性的副本
SuperType.call(this);
}
var instance1 = newe SubType();
instance1.colors.push("black");
console.log(instance1.colors); //"red,blue,green,black"
var instances2 = new SubType();
console.log(instance2.colors); //"red,blue,green" --完美实现了继承构造函数属性
3.组合继承（避免了原型链和构造函数继承的缺陷）
弥补了方式2的缺陷，可以继承实例属性/方法，也可以继承原型属性/方法
既是子类的实例，也是父类的实例
不存在引用属性共享问题
可传参
函数可复用
缺点：
调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）
function SuperType(name) {
this.name = name;
this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName = function() {
console.log(this.name);
};
function SubType(name,age){
//继承属性 --重新创建SuperType构造函数属性的副本
SuperType.call(this,name);
this.age = age;
}
//继承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function() {
console.log(this.age);
};
var instance1 =new SubType("Nicholas",29);
instance1.colors.push("black");
console.log(instance1.colors); // "red,blue,green,black"
instance1.sayName(); // "Nicholas"
instance1.sayAge(); // 29
var instance2 = new SubType("Greg",22);
console.log(instance2.colors); // "red,blue,green"
instance2.sayName(); // "Greg"
instance2.sayAge(); // 22
4.实例继承
特点：
不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果
缺点：
实例是父类的实例，不是子类的实例
不支持多继承
// 定义一个动物类
function Animal (name) {
// 属性
this.name = name || 'Animal';
// 实例方法
this.sleep = function(){
console.log(this.name + '正在睡觉！');
}
}
// 原型方法
Animal.prototype.eat = function(food) {
console.log(this.name + '正在吃：' + food);
};
function Cat(name){
var instance = new Animal();
instance.name = name || 'Tom';
return instance;
}
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // false
5.拷贝继承
特点：
支持多继承
缺点：
效率较低，内存占用高（因为要拷贝父类的属性）
无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）
function Cat(name){
var animal = new Animal();
for(var p in animal){
Cat.prototype[p] = animal[p];
}
Cat.prototype.name = name || 'Tom';
}
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true
6.寄生组合继承
function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}
(function(){
// 创建一个没有实例方法的类
var Super = function(){};
Super.prototype = Animal.prototype;
//将实例作为子类的原型
Cat.prototype = new Super();
})();
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true