this指向问题
this是 JavaScript 语言的一个关键字。
它是函数运行时，在函数体内部自动生成的一个对象，只能在函数体内部使用。
- 情况一：纯粹的函数调用
这是函数的最通常用法，属于全局性调用，因此this就代表全局对象。请看下面这段代码，它的运行结果是1。
var x = 1;
function test() {
console.log(this.x);
}
test(); // 1
- 情况二：作为对象方法的调用
函数还可以作为某个对象的方法调用，这时this就指这个上级对象。
function test() {
console.log(this.x);
}
var obj = {};
obj.x = 1;
obj.m = test;
obj.m(); // 1
- 情况三: 作为构造函数调用
所谓构造函数，就是通过这个函数，可以生成一个新对象。这时，this就指这个新对象。
function test() {
this.x = 1;
}
var obj = new test();
obj.x // 1
运行结果为1。为了表明这时this不是全局对象，我们对代码做一些改变：
var x = 2;
function test() {
this.x = 1;
}
var obj = new test();
x // 2
运行结果为2，表明全局变量x的值根本没变。
- 情况四: apply 调用
apply()是函数的一个方法，作用是改变函数的调用对象。它的第一个参数就表示改变后的调用这个函数的对象。因此，这时this指的就是这第一个参数。
var x = 0;
function test() {
console.log(this.x);
}
var obj = {};
obj.x = 1;
obj.m = test;
obj.m.apply() // 0
apply()的参数为空时，默认调用全局对象。因此，这时的运行结果为0，证明this指的是全局对象。
如果把最后一行代码修改为
obj.m.apply(obj); //1
运行结果就变成了1，证明了这时this代表的是对象obj。
- 情况五: 匿名函数自执行
因为函数执行时，实际是window调用了它，也就是window.函数名();那么，里面的this指向当前调用该函数的对象，就是window。
- 情况六: 定时器中的this指向
如果没有特殊指向，setInterval和setTimeout的回调函数中this的指向都是window。这是因为JS的定时器方法是定义在window下的
作用域链
查找变量的过程。先找自己局部环境内部有没有声明或者是函数，如果有，则查看声明有无赋值或者是函数的内容，如果没有，则向上一级查找。
混入式继承的实现
它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
//混入式继承（拷贝）
//obj2继承到obj1中的成员，可以直接将obj1中的成员拷贝到obj2中即可
var obj1 = {name:"zs",age:10};
var obj2 = {};
// 将obj1中的成员拷贝到obj2中
for (var key in obj1) {
obj2[key] = obj1[key];
}
console.log(obj1);
console.log(obj2);
混入式继承方式看似很简单，但是存在共享数据安全的问题。
var obj1 = {name:"zs",age:10,car:{name:"mini"}};
var obj2 = {};
// 将obj1中的成员拷贝到obj2中
for (var key in obj1) {
obj2[key] = obj1[key];
}
//修改obj1对象中的car属性
obj1.car.name = "bus";
console.log(obj1);
console.log(obj2);
当我们需要修改某些对象中的引用类型对象的时候，会造成其他相关的对象也被修改，这是我们不希望看到的。
原型式继承的实现
回想一下，当我们在访问一个对象中的成员的时候，首先是在当前对象中查找，如果找不到，就往上，
在原型链中依次查找，如果在整个原型链中也不存在该成员，那么就返回undefined。
所以，我们想要在A对象中访问到B对象中的成员，除了将B中的成员添加到A中，如：混入式，我们也可以考虑将B中成员添加到A的原型链中，实现对象成员的共享。
function Animal() {
}
Animal.prototype.name="animal";
function Person() {
}
//修改Person的原型对象
Person.prototype= Animal.prototype;
Person.prototype.useTool = function () {
console.log("use fire");
}
var p = new Person();
console.log(p);
var ani = new Animal();
console.log(ani);
这种方式实现的继承称之为原型继承，实现也是比较方便的，当时和混入式一样，存在数据共享的问题。
原型链继承的实现
这种方式存在问题是，只能继承父类对象原型上的成员，但无法继承父类对象中的成员。
function Animal() {
this.color="red";
}
Animal.prototype.weight=100;
function Person() {
}
Person.prototype = new Animal();
var p = new Person();
console.log(p.color);//red
使用原型链继承方式能够继承到更多的成员。但是依然存在问题：
- 共享的问题
- 无法向构造器传参
借用构造函数继承
function SubClass(color, name, age) {
//SuperClass.call(this,name,age);
SuperClass.apply(this,[name,age]);
this.color = color;
}
以上就是借用构造函数继承（也要对象冒充）的两种实现方式。当然，这种继承方式都存在下面两个问
题：
- 如果父子构造函数存在相同的成员，那么子构造函数会覆盖父构造函数中的成员
- 不能继承原型链中的成员
组合继承
function SubClass(color, name, age) {
//SuperClass.call(this,name,age);
SuperClass.apply(this,[name,age]);//继承构造函数中的成员
this.color = color;
}
SubClass.prototype = new SuperClass();//继承原型链上的成员
问题:组合继承的问题在于在子类中调用父类一次。会导致性能浪费。
寄生式组合继承
// Chinese.prototype = Person.prototype;
// 原型继承改造
//1.创建F构造函数，并且返回实例 new F();
function object(parentPro){
var F = function () {}
F.prototype = parentPro;
return new F();
}
//2.将返回的实例作为子类的原型对象，同时修改子类原型对象的constructor指向子类。
function inhert(par,child) {
var mid = object(par.prototype);
mid.constructor = child;
child.prototype = mid;
}
function Chinese(skin,language,name,age){
this.skin = skin;
this.language = language;
Person.call(this,name,age)
}
inhert(Person,Chinese);
var p1 = new Chinese('黄皮肤','中文','小白',18)
console.log(p1);
p1.say();
总结： ECMAScript 实现继承的方式不止一种。这是因为 JavaScript 中的继承机制并不是明确规定
的，而是通过模仿实现的。这意味着所有的继承细节并非完全由解释程序处理。作为开发者，你有权决
定最适用的继承方式。
Object.create方法的基本使用
//第一种使用方法创建一个空对象，这个空对象中连最基本的原型对象都没有的
Object.create(null)
//创建传递进来的对象，并设置该对象的原型对象为当前的参数
Object.create(obj)
