高级js----- 函数不被销毁的执行空间 、闭包的三种写法及应用、柯里化函数、继承、原型继承

 一、函数的高级应用

           回顾函数

               function  fun(){

               }

            let fun =function(){

            }

            fun()

            let fun = new Function('console.log("内容够")

      补充函数内存结构   

二、闭包是JavaScript语法现象，是函数的高级用法

闭包的概念：

 1. 有一个A函数，在A函数内部返回一个B函数
 2. 在B函数内部，访问A函数内部私有变量
 3. 在A函数外部，有一个变量引用返回的B函数

1. 有函数嵌套，内层函数被返回
2. 内层函数访问外层函数私有变量
3. 返回的内层函数被引用

闭包 形成条件

           1.函数嵌套-  外层函数  内层函数

           2.外部引用返回的内层函数

           3.内层使用外层函数变量

闭包的作用：

           1.会形成一个不被销毁的执行空间，延长变量的生命周期，缺点：容易引起内存泄漏

           2.外部可以访问内部函数的变量-变量作用域扩展-没有形成闭包只能内部函数访问外层函数变量

           3.形成块作用域定义私有变

闭包的特点：

1. 作用域空间不销毁
   优点： 因为不销毁，变量不会销毁，增加了变量的生命周期
   缺点： 因为不销毁，会一直占用内存，多了以后就会导致内存溢出

2. 可以利用闭包，在一个函数外部，访问函数内部的变量
   优点： 可以在函数外部访问内部数据
   缺点： 必须要时刻保持引用，导致函数执行栈不被销毁

3. 保护私有变量
  优点： 可以把一些变量放在函数里面，不会污染全局
  缺点： 要利用闭包函数才能访问，不是很方便

三、闭包的三种写法

1.显示写法：

<script>

        // 显示写法
        // 外层函数
        function fun(){
            let num=100// 3.内层使用外层函数变量
            // 内层函数
            return function(){
                console.log('num:',num)
            }
        }
        let f=fun()//   2.外部引用返回的内层函数
        let f1=fun()

        f()

 2.隐示写法：

    <script>
        // 隐示写法
        let B 
        function fun(){
            let num=100
            B =function(){
                console.log('num:',num)
            }
        }
        fun()
        B ()
</script>

3.函数自调用：

   <script>
// 自调用函数
        let x=(function(){
            let num=100
            return function B(){
                console.log('num:',num)
            }

        })
    </script>

闭包的应用：点赞

  <style>
        * {
            padding: 0;
            margin: 0;
        }

        ul,
        li {
            list-style: none;
        }

        ul {
            display: flex;
            width: 400px;
            height: 100px;
        }

        li {
            width: 100px;
            height: 300px;