闭包和继承

闭包

嵌套的内部函数引用外部函数内的参数，外部调用时全局有一个变量就形成了闭包，执行函数后由于内部函数引用了参数，所以参数不会被回收
常见闭包使用形式：将函数作为另一个函数的返回值；将函数的形参作为实参传给另一个函数
内部函数作为返回值返回时，用一个变量接收；执行之后，由于这个全局变量一直指向这个函数，所以它不会被回收，这时需要释放（变量=null）
垃圾回收机制：垃圾收集器会定期（周期性）找出那些不在继续使用的变量，然后释放其内存。
- 标记清除
- 引用计数

image.png

面向对象

    toString.call(): Object.prototype.toString.call()/({})toString.call(1)
    function fn(){}

--	typeof	.toString()	.toString.call()
1	'number'	'1'	"[object Number]"
'1'	'string'	'1'	"[object String]"
[1]	'object'	'1'	"[object Array]"
{}	'object'	'[object Object]'	"[object Object]"
fn	'object'	函数体	"[object Function]"
Date	'object'	"function Date() { [native code] }"	"[object Function]"
Math	'object'	"[object Math]"	"[object Math]"

    function Person(name) {this.name = name}
        Person.prototype.address = '上海';
    var p1 = new Person('haha');
    p1 instanceof Person //true 是Person 的实例
    p1 instanceof Object //true 是Object 的实例
        p1.constructor.name // Person
        //获取原型对象：
        Person.prototype
        p1.__proto__  //非标准属性，ECMAScript中没有，是某些浏览器为了开发人员调试
        Object.getPrototypeOf(p1)

        //hasOwnProperty和in属性操作
        'name' in p1;   //true
        'adress' in p1;   //true
        p1.hasOwnProperty('adress');   //false
         
         Person.prototype.isPrototypeOf(p1);  //true;
         p1.__proto__  .isPrototypeOf(p1);  //true;

          Person.prototype={name:'haha'};
          Person.prototype.isPrototypeOf(p1);  //false;

hasOwnProperty和in属性操作

in：判断一个对象是否拥有某个属性，如果没有则会到原型对象里查找
hasOwnProperty：只到对象自身查找


![image.png](https://upload-images.jianshu.io/upload_images/12220374-20811a96eee5e907.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
### 继承
- 继承就是让子类拥有父类的资源，减少代码冗余、方便统一操作，但是耦合性比较强
 - call和apply
    - 两个方法是Function原型对象上的方法，都可用来借用方法
    - 第一个参数是调用该方法的对象（函数内部this绑定的对象）
    - 对象.方法.call（调用方法的真正对象，参数1...）
- this 总是指向一个对象
    - 作为对象的方法来调用---this指向当前对象
    - 作为普通函数调用---指向window
    - 作为构造函数和new使用使用---构造函数内部新创建的对象
    - 被call或是apply调用（上下文调用）---第一个参数

function Person(name) {
    this.name = name
    this.age = 18
    this.friends = ['li', 'wang']
}
Person.prototype.say = function(){
    console.log(this.name+':你好')
}

1. 原型链继承
> - 每个函数都能构建出一个对象，这个对象内部有个属性指向这个函数的原型对象；原型对象的本质也是一个对象，也由另外一个构造函数构造出来，也指向那个构造函数的原型对象---形成原型链
> - 新实例无法向父类构造函数传参、继承单一、所有新实例都会共享父类实例的属性（原型上的属性是共享的，一个实例修改了原型属性，另一个实例的原型属性也会被修改！）
> - （新实例不会继承父类实例的属性！）??????

function Student(grade){
    this.grade = grade
}
//Student.prototype = Person.prototype
// 新实例的原型等于父类的实例
Student.prototype = new Person();
Student.prototype.constructor = Student;
var stu = new Student('五年级')
console.log(stu instanceof Person) //true

![image.png](https://upload-images.jianshu.io/upload_images/12220374-6c4c3dc3a9b5101d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
2. 借用构造函数继承
> - 用.call()和.apply()将父类构造函数引入子类函数（在子类函数中做了父类函数的自执行（复制）
> - 特点： 只继承了父类构造函数的属性，没有继承父类原型的属性。
可以继承多个构造函数属性（call多个）。在子实例中可向父实例传参。
> - 缺点：只能继承父类构造函数的属性;无法实现构造函数的复用（每次用每次都要重新调用）;每个新实例都有父类构造函数的副本，臃肿。

function Student(name){
    Person.call(this, name)
}
var stu = new Student('五年级')

3. 组合继承（组合原型链继承和借用构造函数继承）
> - 结合了两种模式的优点，传参和复用
> - 特点：1可以继承父类原型上的属性，可以传参，可复用。2每个新实例引入的构造函数属性是私有的。
> - 缺点：调用了两次父类构造函数（耗内存），子类的构造函数会代替原型上的那个父类构造函数。

function Student(name){
    Person.call(this, name)
}
// 新实例的原型等于父类的实例
Student.prototype = new Person();
Student.prototype.constructor = Student;
var stu = new Student('五年级')

4. 原型式继承 (...)
> - 借助原型，然后基于已有的对象，创建出新对象；同时不需要创建自定义类型
> - 重点：用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。
> - 特点：类似于复制一个对象，用函数来包装。
> - 缺点：1、所有实例都会继承原型上的属性。2、无法实现复用。（新实例属性都是后面添加的）

function content(obj){
    function Tmp(){}
    Tmp.prototype = obj; //继承了传入的参数
    return new Tmp;  //返回函数对象
}
var proto = new Person();//拿到父类实例
var sup = content(proto)
// 或
var sup2 = Object.create(proto)

5. 寄生式继承(...)
> - 重点：就是给原型式继承外面套了个壳子。
> - 优点：没有创建自定义类型，因为只是套了个壳子返回对象（这个），这个函数顺理成章就成了创建的新对象。
> - 缺点：没用到原型，无法复用。

function content(obj){
    function Tmp(){}
    Tmp.prototype = obj; //继承了传入的参数
    return new Tmp;  //返回函数对象
}
var proto = new Person();//拿到父类实例
function subobject(obj) {
    var sub = content(obj);
    sub.name = 'haha';
    return sub
}
var sup2 = subobject(proto); //sup2.name ='haha',继承了subobject属性

6. 寄生式组合继承
> - 寄生：在函数内返回对象然后调用
> - 组合：1、函数的原型等于另一个实例。2、在函数中用apply或者call引入另一个构造函数，可传参

function Student(num, name) {
    Person.call(this, name);
    this.num = num;
}
function Tmp(){}
Tmp.prototype = Person.prototype; 
var stuProto = new Tmp();
Student.prototype = stuProto;
stuProto.constructor = Student;

7. 拷贝属性继承
- [理解js继承的6种方式](https://www.cnblogs.com/Grace-zyy/p/8206002.html)
- [js遍历Object对象可枚举属性、不可枚举属性、原型链属性和自身属性](https://robin-front.github.io/2017/01/13/how-to-enumerate-object-properties.html)