2021-07-12

闭包

**①概念：**指有权访问另一个函数作用域中变量的函数。
**②作用：**闭包可以延迟变量的作用域。
**③缺点：**可能造成内存的泄露。
**④释放：**引用的变量设置为null。
注意：要尽可能少的定义全局变量
1.全局变量可能命名冲突。
2.全局变量比较占内存。

 <script>
        function fn() {
            var a = 10;

            function fn2() {
                console.log(a);
            }
            return fn2;
        }
        var x = fn();
        x();
         </script>

自执行函数

①概念： 声明之后立即执行函数
（function（形参）{函数体}）（实参）
function前除了小括号，还可以使用 + ~ ！new viod
注意点：自执行函数前面的语句必须以分号；结尾，为了代码能正常执行，最好在匿名函数之前加上一个分号;

   <script>
        // var fn = function(){
        //   console.log("hello word");
        // }
        ;
        (function(index) {
            console.log(index);
        })(10);

        // fn();
        // console.log(fn);
    </script>

let、const

① 共同点（与var的区别）： 声明变量的语句；不存在变量的提升；不能重复声明；存在块级作用域
② 不同： const同于声明常量；const一旦声明，必须赋值；const一旦赋值，不能修改
注意： 如果const保存的是复杂数据类型，本质上变量保存的是地址。只要地址不变，就不算修改
**块级作用域：**只要遇到大括号就会形成一个作用域，这个作用域就叫做块级作用域。 for循环中的小括号也会形成一个作用域

    <script>
        // var a = 10;
        // let b = 20;
        // const c = 30;
        // console.log(a);
        // console.log(b);
        // console.log(c);//返回值10 20 30

        // var a = 123;
        // if (true) {
        //   a = "abc";
        //   console.log(a);
        //   var a;
        // }//返回值字符串abc

        // if (true) {
        //   // var a = 10;
        //   const a = 0;
        //   let a = 10;
        //   console.log(a);
        // }//报错

        // const PI = "3.1415926";
        // PI = "3.1415926535";//报错

        const lis = document.querySelectorAll("li");
        const person = {
                name: "zhangsan",
                age: 20
            }
            // person = {
            //     name: "zhangsan",
            //     age: 20
            // }
        console.log(person);//返回obj
    </script>

解构赋值

对象：
let{变量1，变量2}={属性名1，属性名2}
① 变量名必须与属性名相同
② 如果不想让变量名与属性名相等，可以取别名 格式：let（属性名1：变量1）={属性1}
③ let 变量名1=对象.属性名1；let 变量名2 = 对象.属性名2
④ 如果是嵌套解构，就按照原来对象的结构，把不需要的属性删除，把需要的属性的属性值删除，就可以成功解构赋值了
数组
let[变量1，变量2]=[元素1，元素2] ①：变量与元素的关系是按照顺序对应的
②：let 变量1=数组[0]；let 变量2 = 数组[1]
字符串
按照数组来解构

按照对象来解构
① length属性 let{length} = 字符串
② let{0：变量1,1：变量2} = 字符串 （变量1保存的字符串中的第一个字符，变量1保存的字符串中第二个字符）

    <script>
        // var person = {
        //         username: "zhangsan",
        //         age: 25,
        //         professer: {
        //             type: "打工人",
        //             salary: 5000
        //         }
        //     }
        // 声明三个变量将三个属性取出
        // var username = person.username;
        // var age = person.age;
        // var professer = person.professer;
        //console.log(username,age ,professer)  //返回值
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210712213944661.png)


        // 解构赋值的写法

        // 完全解构
        // var {username,age,professer:abc} = person
        // 不完全解构
        // var {username,professer:{salary}} = person;

        // console.log(username,abc);

        // var arr = ["刘德华","成龙","张国荣","周慧敏","王祖贤"];
        // let [ldh,cl,zgr,zhm,wzx] = arr;
        // let {0:first} = arr;
        // console.log(first);  //返回值刘德华

        let [a, b, c, d, e] = 'hello'
        let {
            s: x,
            y,
            z
        } = "hello"
        console.log(a, b, c);
        console.log(a, b, c, d, e);//返回值h e l l o

        // let x = 1;
        // let y = 2;

        // // 让x与y的值交换。  x=2  y=1
        // [y, x] = [x, y];
        // console.log(x, y);
    </script>