////语法扩展  
//箭头函数 简化了函数定义
        var f = function(v){
            return v;
        };
        f(2);
        var f = v =>v;
       // 变量名 = 参数 = 函数体
       //不传参数
       var a =()=>'abc';
       a();
      // var a = function() {return 'abc'};
      //传多个参数
      var sum = (n1,n2) => n1+n2;
      sum(2,4);
        //   var sum = function(n1,n2){
        //       return n1+n2;
        //   };

        //map 数据结构对象  是键值对的集合 它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。
        const　m = new Map();
        m.set('name','lili');
        m.get('name');
        m.size;  //长度

        //for...of 循环 
        var m2 = new Map();
        m2.set('name','123');
        for(let [key,value] of m2) {
             console.log(key+'+'+value); 
        }
    }
    
////////////////////////////////////////////////
  //字符串解构
        var [a,b,c] = 'hello';

        //函数参数的解构赋值
        function fun([a,b]){
            return a+b;
        };
        fun([2,5]);  //7
        //默认值
        function fun([a=0,b=0]){
            return a+b;
        };
        fun([]);  //0
        function fun([a=0,b=0]){
            return a+b;
        };
        fun([3]);  //3

        //对象
        function fun({a=0,b=0}){
            return a+b;
        };
        fun({a:2,b:5});  //7
        function fun({a=0,b=0}){
            return a+b;
        };
        fun({a:2});//2

        //了解
        function fun({a=0,b=0} ={}){   //变量为默认值
            return [a,b];
        };
        fun({a:2,b:5});  //2,5
        function fun({a=0,b=0} ={}){
            return [a,b];
        };
        fun({a:2});//[2, 0]
        function fun({a=0,b=0} ={}){
            return [a,b];
        };
        fun();//0,0

        function fun({a,b} ={a:2,b:7}){  //参数为默认值
            return [a,b];
        };
        fun({a:5,b:5});//5,5

        function fun({a,b} ={a:2,b:7}){  //参数为默认值
            return [a,b];
        };
        fun({a:5});// 5 undefined

        function fun({a,b} ={a:2,b:7}){  //参数为默认值
            return [a,b];
        };
        fun();  //2,7

        function fun({a,b} ={a:2,b:7}){  //参数为默认值
            return [a,b];
        };
        fun({});//undefined undefined
        //数组
        function num(){
            return [1,2,3]
        };
        let [a,b,c] = num();
        //对象
        function num2(){
            return obj = {age:20,name:'abc'};
        }
        let {name,age} = num2(); 

        //JSON
        let data ={
            name:'abc',
            age:18,
            friends:['x','y','z'],
            obj:{a:'a',b:'b'}
        };
        let {name,age:a=20,friends,obj} = data;
          //a =18   obj.a   friends[1]
    }
//////////////////
    //扩展
    //字符串扩展 substring(start,stop) 不包含stop   substr(start,length) indexOf() 首次出现的位置
      let str = 'hello world';
      str.startsWith('h');   //字符串是否在原字符串的头部  返回true false  区分大小写 第二个参数表示搜索的位置
        str.endsWith('h');   //字符串是否在原字符串的尾部  第二个参数表示搜索的位置
        if(str.indexOf('h') !=-1){}
        //匹配是否存在于字符串  第二个参数表示搜索的位置
        if(str.includes('h')){conslole.log('ok')}else {};

         //字符串循环 for  of
         for(let s of  'helloworld'){    
             console.log(s)  //h e l l ....
         };

         //repeat()    重复
         'a'.repeat(5);  //aaaaa
         'abc'.repeat(3);  //abcabcabc
         'abc'.repeat(0);  //''
         'abc'.repeat(3.6);  //取整

         //补全
         let s2 = 'a';
         s2.padStart(5,'xyz');  //xyzxa   头部补全
         s2.padEnd(5,'xyz');  //axyzx  尾部补全

         //数值扩展
         parseInt(2.2345);
         Number.parseInt(2.2345);
         //判断一个数值是否为整数
         Number.isInteger(10);   //true
         Number.isInteger(10.342);   //false

         //Math 对象    执行数学任务
         Math.random()   //随机数  0-1 但不包含0/1
         Math.ceil(3.6)  //向上    4
         Math.floor(3.9)  //向上    3
         Math.round(3.9)   //四舍五入   
         Math.trunc(3.6)  //3   
         Math.trunc(-3.6)   //-3
         Math.sign(-3.6) //判断数值是正数，负数，零。。。。
         //正数 +1   负数 -1  0   0  其它值 NaN

         //ES6 指数运算符  2**2
         //2**2   4   2**3  8  3**2   9
         let a =2 ; a+=1;  // ===  a=a+1;
         let a =2 ; a**=2;  // ===  a=a*a;
         let a =2 ; a**=3;  // ===  a=a*a*a;

         //函数扩展
         //es5
         function fun(x,y){
             y = y || 10;
             console.log(x,y)
         };
         fun(2);
         // ES6
         function fun(x,y=10){
             console.log(x,y)
         };
         fun(2);
         //rest参数
         function fun(...values){   //arguments
             console.log(values)   //values[2]
         };
         fun(2,32,343,324,34,432,5325,24,432,42,42);
         //箭头函数
         let f = v=>v;
         let f = function(v){
             return v;
         };
         //参数为空    
         let f = ()=>'123';
         //多个参数
         let f = (n1,n2)=>n1+n2;
         let f = (n1,n2)=>{abc()};
         //对象
         let f = (n1,n2)=>({name:n1,age:n2});
         //传默认值
         let f = (n1,n2=10)=>{
             console.log(n1,n2)
         };
         f(3)  //3 10

        //对象解构
        let fun =({a=0,b=0} ={})=>{   //变量为默认值
            return [a,b];
        };
        fun({a:2,b:5});  //2,5