day22-闭包和继承

                                day22-闭包和继承

一、闭包

1. 闭包形成原理
   闭包：是由于作用域嵌套形成的一种执行空间不被销毁的场景
   闭包形成：通常是由大函数嵌套小函数，小函数使用大函数的变量，在大函数外跟小函数产生引用关系

   平常函数调用在内存中的执行流程： js执行代码是在 调用栈(call stack) 内存中执行的，函数执行是先在调用栈中形成一个独立的空间，然后在这个空间中执行代码，当空间中的代码执行结束后，空间中的代码跟全局代码无关联，就会销毁这个空间，下面的代码进入调用栈执行，执行结束出栈 。。。

     闭包：    全局定义b变量，接收局部中返回的小函数，只要全局变量还存在，局部中的小函数就会一直存在 ，小函数要存在，f1的空间就必须一直存在，f1的空间要一直存在，f1中的变量a就会一直存在，调用全局b函数，执行f1中的小函数，小函数中访问的f1中的变量，多次调用其实访问的是同一个变量a
   

2. 闭包优缺点
   优点：全局可以操作局部的变量；延长了变量的生命周期；保护了变量的私有性

     缺点：闭包的执行空间不销毁，如果滥用闭包会造成内存泄露/溢出（代码停留在内存中不销毁，导              致内存满了，执行不了其他代码）----要销毁这个执行空间，可以将全局接收小函数的变量赋值为null
   

3. 闭包应用场景
   a.在循环中执行异步代码，在异步代码中使用循环的变量
   b.防抖
   c.节流
   d.函数柯里化

4. 防抖
   当某些操作频繁被触发，而我们只需要最后一次的时候就需要防抖

    js中有一个关键字arguments--用于接受所有的实参
   
      document.onmousemove = fn(1000, function (e) {           
                    document.querySelectorAll('span')[0].innerText = e.pageX 
                    document.querySelectorAll('span')[1].innerText = e.pageY    
       })     
     function fn(time,handler) {         
                 var timer         
                 return function() {            
                          var _this = this             
                          var _arguments = arguments            
                          clearInterval(timer)             
                          timer = setTimeout(function() {                 
                          handler.call(_this,..._arguments)             
                          },time)        
                  }     
         }
   
   

5. 节流
   当某些操作频繁被触发，不需要这么频繁的时候使用节流
   document.onmousemove = fn(1000, function (e) {

         document.querySelectorAll('span')[0].innerText = e.pageX        
         document.querySelectorAll('span')[1].innerText = e.pageY    

   })
   function fn(time, handler) {

          var starTime = +new Date()       
          return function () {            
                  var endTime = +new Date()            
                  if(endTime - starTime >= 1000) {               
                           handler.call(this,...arguments)             
                            starTime =  endTime            
                   }      
            }   
   }
   
   

6. 函数柯里化
   柯里化：一个函数本来应该有多个参数，将这个函数改造，让这个函数值传递一个参数，要实现原本 的功能，就传递多次

     function fn(a) {    
             return function(b) {         
                     return function(c) {             
                             return function(d) {                 
                                     return a + b + c + d             
   
                              }     
                     }
              }
       console.log(fn(1)(2)(3)(4) === 10);
   

一、继承

    让一个对象拥有其他对象的属性和方法

1.原型继承

   通过修改对象的原型，让对象拥有其他对象的方法
    弊端： 继承来的属性在原型上，不在自己上，当给自己添加同名属性时，就无法使用原型的属性了。

2.借用函数继承

    在子构造函数中通过call调用父构造函数并改变其中的this为子构造函数的this
     弊端：只能继承构造函数中给的属性，无法继承父对象的原型上的方法

3.组合继承

    原型+借用

3.es6的继承

    es6提供了class关键字用来定义类
            类：抽象的对象                    类--构造函数
            对象：实例化的类                 对象--实例对象--new出来的对象            class语法：    class 类名{                             //定义属性有两种写法
                                属性名 = 值                 //第一种写法      
                                constructor() {            //第二种写法     
                                        this.属性名 = 值         
                                }         
                                方法名() {         }    

                                 }

        继承语法：class 子类 extends 父类{}    
        注意：当子类有constructor的时候，在子类的constructor中的最前面，必须先调用super()
        class Person extends Animal{    
                constructor(age, n) {         
                        super(n) // super其实就是在调用父类的constructor         
                        this.age = age     
                } 
        }