关于javascript:day22闭包和继承

38次阅读

共计 1955 个字符，预计需要花费 5 分钟才能阅读完成。

                                day22- 闭包和继承

一、闭包

闭包造成原理
闭包：是因为作用域嵌套造成的一种执行空间不被销毁的场景
闭包造成：通常是由大函数嵌套小函数，小函数应用大函数的变量，在大函数外跟小函数产生援用关系

平时函数调用在内存中的执行流程：js 执行代码是在调用栈 (call stack) 内存中执行的，函数执行是先在调用栈中造成一个独立的空间，而后在这个空间中执行代码，当空间中的代码执行完结后，空间中的代码跟全局代码无关联，就会销毁这个空间，上面的代码进入调用栈执行，执行完结出栈。。。
```
  闭包：全局定义 b 变量，接管部分中返回的小函数，只有全局变量还存在，部分中的小函数就会始终存在，小函数要存在，f1 的空间就必须始终存在，f1 的空间要始终存在，f1 中的变量 a 就会始终存在，调用全局 b 函数，执行 f1 中的小函数，小函数中拜访的 f1 中的变量，屡次调用其实拜访的是同一个变量 a
```

闭包优缺点
长处：全局能够操作部分的变量；缩短了变量的生命周期；爱护了变量的公有性

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

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

防抖
当某些操作频繁被触发，而咱们只须要最初一次的时候就须要防抖

 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)        
               }     
      }

节流
当某些操作频繁被触发，不须要这么频繁的时候应用节流
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            
                }      
         }   
}

函数柯里化
柯里化：一个函数原本应该有多个参数，将这个函数革新，让这个函数值传递一个参数，要实现本来的性能，就传递屡次
```
  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     
                } 
        }

正文完