ECMAScript的let，const，正则，字符串

1.let 和 const

var log = function() {
            console.log.apply(console, arguments)
        }

        function test() {
            for (let i = 1; i < 3; i++) {
                log(i);
            }
            // log(i);
            // es6 默认开启严格模式

            // let 存在作用域 ，不能重复定义变量
        }

        test()

        function last() {

            const PI = 3.14;
            // const 常量 不能被改变，声明的时候必须赋值

            const k = {
                a: 1,
            }
            k.b = 3;
            //对象是引用类型  对象属性可以被改变

            log(PI, k);
        }

        last();

2.解构赋值

		{
            // 数组的解构赋值
            let a, b, rest;
            [a, b] = [1, 2]
            log(a, b)
        }

        {
            let a, b, rest;
            [a, b, ...rest] = [1, 2, 3, 4, 5, 6];
            log(a, b, rest)
            // 不加三个点，结果为[1, 2, 3]
        }

        {
            // 对象解构赋值
            let a, b;
            ({a, b} = {a: 1, b: 2})
            log(a, b);
        }

        {
            let a, b, c, rest;
            [a, b, c] = [1, 2];
            log(a, b, c);
            // 没有在元素上成功配对，会被赋值为 undefined
        }

        // 解构赋值使用的场景

        {
            // 交换变量值
            let a = 1;
            let b = 2;
            [a, b] = [b, a];
            log(a, b);
        }

        {
            function f() {
                return [3, 4]
            }
            let a, b;
            [a, b] = f();
            log(a, b);
        }

        {
            // 当函数返回多个值的时候，可以选择型的赋值
            function f() {
                return [1, 2, 3, 4, 5]
            }
            let a, b, c;
            [a, , , b] = f();
            log(a, b);
            // 选择性接收返回的值
            // 1 4
        }

        {
            // 当函数返回多个值的时候,不能确定函数返回的值是多少个
            function f() {
                return [1, 2, 3, 4, 5]
            }
            let a, b, c;
            [a, ...b] = f();
            log(a, b);
            // 1  [2, 3, 4, 5]
        }

        {
            // 给对象赋值，对象的左右两边必须都是对象
            let o = {
                p: 42,
                q: true,
            }
            let {p, q} = o;
            log(p, q);
        }

        {
            // 重新给对象的属性赋值
            let {
                a = 10,
                b = 5
            } = {a: 3};
            log(a, b);
        }

        {
            let methodData = {
                title: 'abc',
                test: [{
                    title: 'test',
                    desc: 'description'
                }]
            }
            // 要一一对应
            let {
                title: esTitle,
                test: [{
                    title: cnTitle
                }]
            } = methodData;
            log(esTitle, cnTitle);
        }

3.正则扩展

const {log} = console
        // ES5
        // RegExp 是正则表达式的缩写。
        //当您检索某个文本时，可以使用一种模式来描述要检索的内容。RegExp 就是这种模式。
        let regex1 = new RegExp('xyz', 'i');
        let regex2 = new RegExp(/xyz/i);

       log(regex1.test('xyz123'), regex2.test('xyz123'));
    
        // ES6
        let regex3 = new RegExp(/xyz/ig, 'i');
        // 当出现两个参数的时候，后面的修饰符会覆盖前面的

        // flags是ES6里面用来获取正则修饰符的
        log(regex3.flags);



        {
            let s = 'bbb_bb_b';
            let a1 = /b+/g;
            let a2 = /b+/y;

            log('one', a1.exec(s), a2.exec(s));
            // 第一次两个都匹配到了bbb
            log('two', a1.exec(s), a2.exec(s));
            // 均为全局匹配
            // 第二次 g 模式下的匹配到了相应的，
            // 但是 y 模式下的没有匹配到，因为 y 模式下的开启了判断粘连模式

            // 判断是否开启粘连模式
            log('粘连模式', a1.sticky, a2.sticky);

        }



        {
            // u 修饰符 用来处理Unicode 字符
            log('u-1', /^\uD83D/.test('\uD83D\uDC2A'));     // true
            log('u-2', /^\uD83D/u.test('\uD83D\uDC2A'));    // false

            log(/\u{61}/.test('a'));    //false
            // 不加 u 修饰符，无法识别
            log(/\u{61}/u.test('a'));   //true

            // 超过四个字节
            log(`\u{20BB7}`);

            let s = '????';

            log('u', /^.$/.test(s));
            // 超过2个字节的，要匹配，最好加上/u, 不然会出现意想不到的错误
            log('u-2', /^.$/u.test(s));

            // 超过两个字节的，最好用 /u
            // .修饰符不一定可以匹配所有的（无法识别超过两个字符的） 例如换行符，回车符之类 
            
        }

4.字符串的扩展

const {log} = console

        {
            log('a', `\u0061`);
            log('s', `\u20BB7`);
            // s ₻7，被当成两个字节处理
            // 超过最大识别码，不能被正常识别

            // 在编码加上大括号就可以正确识别
            log('s', `\u{20BB7}`); 

            let s = '????';           

        }

        {
            let s = '????';  
            log('length', s.length);  // 2

            // 取字符
            log('0', s.charAt(0));
            log('1', s.charAt(1));
            // 无法正确识别编码

            // Unicode的码值
            log('at0', s.charCodeAt(0));
            log('at1', s.charCodeAt(1));
            // 可以识别

            let s1 = '????a'; // ???? 两个字节
            log('length1', s1.length);  // 3
            log('code0', s1.codePointAt(0));
            log('code0',s1.codePointAt(0).toString(16));
            log('code1', s1.codePointAt(1));
            log('code2', s1.codePointAt(2));  

        }

        {
            log(String.fromCharCode("0x20BB7"));
            // es5 不能正确识别

            log(String.fromCodePoint("0x20BB7"));
            //  es6 可以正确识别

        }

        // 字符串的遍历器接口

        {
            let str = '\u{20BB7}abc';
            for(let i = 0; i < str.length; i++) {
                log('es5', str[i]);
            }
            // 不能正确识别

            for (let code of str) {
                log('es6',code)
            }
            // 可以正确识别
        }
        {
            let name = "list";
            let info = "hello world";
            let m = `I am ${name}, ${info}`;
            log(m);
        }


        {
            // 实现补白效果(前面的长度为2， 不够用0进行填补)
            log('1'.padStart(2, '0'));
            log('1'.padEnd(2, '0'));
        }
        // 标签模板

        {
            let user = {
                name: 'list',
                info: 'hello world'
            };
            abc`i am ${user.name}, ${user.info}`;
            function abc(s, v1, v2) {
                log(s, v1, v2);
                return s + v1 + v2
            }
        }
        {
            let str = "string";
            log('includes', str.includes("r"));
            log('start', str.startsWith('str'));
            log('start', str.endsWith('ng'));
            log('repeat', str.repeat(2));
            log(String.raw`Hi\n${1 + 2}`);
            log(`Hi\n${1 + 2}`);
        }