ES6（数组扁平化、字符串、let、const、解构赋值、闭包函数）

数组扁平化

将多维数组转化为单层数组

ES语法

• flat（参数）
• 想让几层数组扁平化就填几，也可以写Infinity，全部扁平化

        var arr = [1,[5,9,[5,6,1]],1,5,[4,8,9,[4,5,6,[4,[5]]]],5]
        console.log(arr);

        // ES6语法 falt(参数)   参数需要扁平化几层就填几，可以写Infinity  
        var arr1 = arr.flat(Infinity);
        console.log(arr1);

数组先转字符串再转数组

        // 数组先转字符串再转数组
        var arr2 = arr.toString().split(",").map(function(r){
            return Number(r)
        });
        console.log(arr2);

数组转JSON字符串，保留原数据格式

        // 数组转换成json字符串,再替换掉[]
        var arr3 = JSON.stringify(arr).replace(/(\[|\])/g,"").split(",").map(function(r){
            return Number(r)
        });
        console.log(arr3);

封装函数，利用some循环查找是否包含数组

        // 封装一个函数利用some检测是否有数组
        function getArr (arr){
            while(arr.some(function(r){
                return Array.isArray(r)
            })){
                arr=[].concat(...arr);
                console.log(arr);
            }
            return arr;
        }
        var arr4 = getArr(arr);
        console.log(arr4);

字符串

模板字符串

用 `` 包起来，可以解析变量、方法，变量或者方法要用${}包起来

        // 模板字符串 ``
        var obj = {
            name:"彭忠杰",
            age:18,
            idendity:"马跃磊儿子",
        }
        var str = `我叫${obj.name}我是${obj.idendity}`;
        console.log(str);
        function intro () {
            return "我叫彭忠杰，我有一个好爸爸"
        }
        var str2 = `这是我的自我介绍：${intro()}`;
        console.log(str2);

字符串的方法

• startswith(string) 查看参数字符串是否在原字符串的开头，返回true/false
• endswith(string) 查看参数字符串是否在原字符串的末尾，返回true/false
• repeat（n） 字符串重复n次

        // startsWith 表示参数数字是否在原字符串的开头
        var str3 = "hello world!";
        console.log(str3.startsWith("he"));  // true
        console.log(str3.startsWith("e"));  // false
        // endswidth 表示参数数字是否在原字符串的末尾
        console.log(str3.endsWith("!"));   // true
        console.log(str3.endsWith("h"));  // false
        console.log("最是人间留不住".repeat(2));

let、const

let 声明变量，块级作用域，变量不提升

特点：

1. 防止变量泄露
2. 不存在变量提升处理语法问题
3. 暂时性死区
4. 不能重复声明

暂时性死区是指，一个变量在用let或者const声明变量之前赋值，就会报错，那么在let和const声明前面的区域，就是这个变量的死区

const 声明常量，值不可以修改，块级作用域，声明函数，内容地址不能修改，必须赋值。

var 函数作用域，变量提升，值可以修改，可以重复声明，可以不赋值
let 块级作用域，变量不提升，值可以修改，同一块级下不可重复声明，可以不赋值
const 块级作用域，变量不提升，值不可以修改，同一块级下不可重复声明，必须赋值

        let arr = [8, 7, 6, 5]
        // let

        // for (let i = 0; i < arr.length; i++) {
        //     console.log(i);
        // }
        // console.log(i);  //  i is not defined

        // for(var i = 0 ; i < arr.length ; i ++){
        //     console.log(i);
        // }
        // console.log(i);   // 4


        // 暂时性死区
        // for (let i = 0; i < 4; i++) {
        //     setTimeout(() => {
        //         console.log(i);  // 0 1 2 3
        //     });
        // }

        // for (var i = 0; i < 4; i++) {
        //     setTimeout(() => {
        //         console.log(i);  // 4 4 4 4
        //     });
        // }

        // const 常量
        const chang= 123;
        // chang = 456 ;  // 报错
        console.log(chang);

解构赋值

ES6允许从对象/数组，按照对应的位置进行赋值

        let [a,b] = [2,3];  // => let a=2,b=3;
        console.log(a,b);
        let[c,d,e] = [5,6]//  如果数据不过，就是undefined
        console.log(c,d,e);  // 5 6 undefined

还可以剩余参数，剩余参数要写在后面

        // 剩余参数  ...
        let [f,...g] = [1,2,3,5,4];   // ...g就是接收多余的参数
        console.log(f,g);  // 1  [2, 3, 5, 4]

        function fn(e){
            console.log(e);
        }
        fn(1,2,3);  // 只输出1

        function fn2(...e){   
            console.log(e);
        }
        fn2(1,2,3);  //  [1, 2, 3]

对于对象，则根据key值返回对应的value值

        // 对于对象，对应值为key返回的value
        let obj = {
            name:"彭忠杰",
            age:18,
            height:200
        }
        let{age,height,name} = obj;
        console.log(age,height,name);

另外可用于交换值

        // 交换值
        let i = 1 , j = 2 ;
        console.log(i,j);  // 1 2
        [i,j] = [j,i]
        console.log(i,j);

闭包函数

• 闭包就是让外部能够获取函数内部的变量
• 作用
  - 读取函数内部的变量，使这些变量保存在内存中，不会在外部函数执行完以后就销毁
• 闭包的缺点：
  - 内存消耗大，IE中会导致内存泄漏，父级函数的变量尽量不要修改

另外注意：
js的作用域是静态的，函数的作用域是定义函数时的作用域，而不是调用函数时的作用域

        function fn3(){
            let a=10;
            return (function(){
                return a
            })()
        }
        var aa = fn3();
        console.log(aa);  // 10 

        var a = 8 ;
        function getA(){
            console.log(a);
        }
        getA();   // 8 这时函数的作用域是全局的

        function fn () {
            var a = 9 ;
            return getA()
        }
        fn();  // 8 因为getA的作用域是全局的，读取不了fn内部的变量