ES6新特性使用小结（一）

一、let const 命令

　　

'use strict';
/*function test(){
 //let a = 1;
    for(let i=1;i<3;i++){
        console.log(i)
    }
    console.log(i);     //引用错误

    let a = 1;
    let a= 2;       //报错  let 不能重复定义同一个变量
}
test();
*/
function last(){
    const PI = 3.1515926;
    //const  也具有块级作用域  const 声明变量时 *必须赋值
   // PI = 8;         报错 const声明的原始类型常量无法修改 PI is readOnly
   // console.log(PI);

    const K = {
        a:1
    };
    K.b=3;                          //const声明的引用类型可以随意修改  const指向指针
    K.a = 0;
    console.log(PI,K);
}
last();

二、解构赋值

　　

{
    let a, b, reset;
    [a, b] = [1, 2];
    console.log(a, b);                    // a =1  b =2
}

{
    let a, b, reset;
    [a, b, ...reset] = [1, 2, 3, 4, 5, 6];
    console.log(a, b, reset);             //a = 1  b= 2  reset = [3,4,5,6]
}

{
    let a, b;
    ({a, b} = {a: 1, b: 2});
    console.log(a, b)                //1,2
}

{
    let a, b, c;
    [a, b, c = 3] = [1, 2];
    console.log(a, b, c);         //1,2,3

    [a, b, c] = [1, 2];
    console.log(a, b, c);         //1,2,  undefined
}

{
    let a = 1;                  //      使用场景    1 、变量交换
    let b = 2;
    [a,b]=[b,a];
    console.log(a,b);       // 2  1
}

{
    function f (){              //      使用场景   2、 接收函数返回的多个值
        return [1,2];
    }
    let a ,b;
    [a,b]=f();
    console.log(a,b);      //1 2
}

{
    function f(){
        return[1,2,3,4,5]
    }
    let  a,b,c;
    [a,,,b,c]=f();
    console.log(a,b,c)                      //1  4   5                       选择性接收
}
{
    function f(){
        return[1,2,3,4,5]
    }
    let  a,b,c;
 /*
   [a,...b]=f();
    console.log(a,b)                      //1  [2,3,4,5]                      选择性接收
 */
    [a,,...b]=f();
    console.log(a,b)                    //1  [3,4,5]                      选择性接收
}

{
    let o = {p:42,q:true};
    let {p,q} = o;
    console.log(p,q);       // 42 true
}

{
        let {a=10,b=5} = {a:3};
        console.log(a,b)  // 3 5
}

{
    let metaData = {
        title:'abc',
        test:[{
            title:'test',
            desc:'description'
        }]
    }
    let {title:esTitle,test:[{title:cnTitle}]} = metaData;

    console.log(esTitle,cnTitle);        // abc      test
}

三、RegExp扩展

{
    //  ES5 中创建 RegExp 对象的两种方式
    let regexp = new RegExp('xyz', 'i');      // i 忽略大小写
    let regexp1 = new RegExp(/xyz/i);

    console.log(regexp.test('xyz123'));         //true
    console.log(regexp1.test('xyz123'));        //true

    //  ES6

    let regexp2 = new RegExp(/xyz/ig,'i');       //ES6中可以接受两个参数 第二参数会覆盖修饰符
    console.log(regexp2.flags);     //  i           RegExp.flags 得到修饰符
}

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

    /*
    *  修饰符  g  y
    *       g修饰符会在匹配过程中碰到不匹配的字符就忽略
    *       y修饰符从开始检测在碰到不匹配的字符就停止       粘连模式
    * */

    console.log('one',a1.exec(s),a2.exec(s));       //[bb]  [bb]
    console.log('two',a1.exec(s),a2.exec(s));       //[bb]  null

        //RegExp.sticky 判断一个正则对象是否开启的粘连模式
    console.log(a1.sticky,a2.sticky);       //fasle true
}

{
    /*
    *   修饰符 u       通关unicode码来匹配   对大于两个字符的要用 u 来匹配
    * */

}

四、String扩展

{
    /*
     *   字符UNICODE表示法
     * */
    console.log('a', `\u0061`);          //a     a
    console.log('s', `\u20bb7`);         //s     ₻7          当unicode码超过了 0xffff 时 会显示为两个字符
    //\u20bb    7
    console.log('s', `\u{20bb7}`);       //s