关于javascript: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     
                } 
        }