ES6语法

变量

let 声明的变量是在当前的作用于内有效，const 声明的是只读变量 -常量
let const 声明的变量不存在变量的声明提前， 声明变量不能重复声明

  {
           var a=10;
            let b = 20;
            console.log(b);
        }
        console.log(a);
      //  console.log(b);作用域外无效

const 声明的常量，只能读取，不能修改
es6声明多个变量，按照对应的结构赋值

// let [a,b,c,d] = [1, 2, 3, ["a", "b"]];
      //console.log(a,b,c,d);
      let [a,b]=[1, 2, 3, 4, 5];
         console.log(a, b);    

结构统一 ，按照位置取值

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

结构赋值 也可以设置默认

let [a=10,b]=[,2];
 console.log(a,b);

对象解构赋值

et {name,sex}={name: "张三", sex: "男"};
    console.log(name, sex);

字符串的解构赋值

 /*let [a,b,c,d]="save";
         console.log(a,b,c,d);*/
        // 字符串    String  对象
        /*let {length : len}="save";
         console.log(len);*/

es6 字符串遍历器 for of

  let [a,...b] = ["hello",1,2,3,4,5];
        for(let char of a){
            console.log(char);
        }
            for(let str of b){
                console.log(str);
            }

模板字符串${} 用于字符串拼接
将字符串修改为反引号 ` 里面写模板字符串

let[a,b]=["abcd","efgh"];
        let c = `我是一个字符串：${a}，我是第二个字符串：${b}。`;
        console.log(c);

在实用性箭头函数的时候一定要注意内部的this 指针问题
因为箭头函数 保持上下文this一致 内部this 和 外部this一致

/*console.log(this);
            let a=["a","b","c","d"];
            //map 映射
            let b=a.map((val,index)=>{
                console.log(this);
                if(index%2==0)
                {
                    return val+index;
                }
                else {
                        return val;
                }
            });
           console.log(b);*/

扩展运算符 拆开数组

console.log(...[1,2,3,4,5]);

扩展运算符和函数的使用

function fun(array,...item){
         array.push(...item);
         }
         let array=[];

         fun(array,...[1,2,3,4,5]);
         console.log(array)

扩展运算符 替换apply args 数组型

function f1(a,b,c){
         console.log(a,b,c);
         }
         let m=[1,2,3];
         //f1.apply(null,m);
         f1(...m)

扩展运算符 复制数组

let a=[1,2,3];
         let b=a;
         b[0]="a";
         console.log(b,a);

扩展运算符 ，复制数组，修改其中一个，另一个不会发生变化

  let a=[1,2,3];
         let b= [...a];
         b[0]="a";
         console.log(a, b);

扩展运算符合并数组

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

数组的扩展方法 Array.from(); 将类数组对象 转化为正真的数组

let a={
         0:"a",
         1:"b",
         length:2
         }
         console.log(Array.from(a));

es6 允许直接在对象内部声明属性和方法
es6 扩展的super 指向当前对象的原型对象 this 指向当前对象
super 指向当前对象的原型对象
super 只能写在对象的方法内部 不能直接写在属相上 和 方法 的返回值上

*let proto={
         sleep(){
         console.log("睡觉");
         }
         }
         let person={
         name:"张三",
         logproto(){
         super.sleep();
         }
         }

//下面的方法获取取决于对象属性的可枚举性 true false该属性会被忽略
//Object.keys 获取对象的所有的键
//Object.values 获取的对象的所有键值
//Object.entries 获取对象的键值 返回是一个数组

let obj = {
            name: "1",
            sex: "2"
        };
        let ob = {
            eat()
        {
            console.log("吃饭");
        }
    }
    console.log(Object.keys(obj));
    console.log(Object.values(obj));
    console.log(Object.entries(obj));

//proto 获取当前对象的原型对象
console.log(obj.proto);
//设置对象的原型对象
Object.setPrototypeOf(obj, ob);
console.log(obj.proto);
//获取对象的原型对象的
console.log(Object.getPrototypeOf(obj));

ES6 Set Map 数据结构
* Set 里面存储的是指 并且值是唯一的 没有重复的
* Set 本身是一个构造函数
* 使用的时候 new
* Set 的构造函数constructor 是自己的本身
* Size 属性 返回的是Set对象里面的成员变量
* add 方法 将值添加到Set里面
* delete 方法 删除某个值 返回true false
* has 方法 检测是否有某个值 返回true false
* clear 方法 清除所有的成员 没有返回值的
*

 let set=new Set();
         set.add(1);
         set.add(2);
         set.add(3);
         set.add(4);
         set.add(4);//这个添加的相同的值不会再出现 使用的是set的特性

         console.log(set.delete(2));//true
         console.log(set.has(1));//true
         set.clear();
         console.log(set);
         console.log(set.size);//返回的是长度

set 对象里面存储数组 不能直接存储键：值对象
WeakSet 类似Set 也是唯一的 它里面可以存储数组和对象
WeakSet 成员必须是一个对象
let a1 = [1, 1, 2, 2, 3]; //一维数组赋值直接报错 原因是一维数组的成员不是一个对象
二维数组可以存储
写的代码可以执行 页面刷新weakset 数组可能为空
weakset 里面的值可能会随时消失

let a2=[[1,2],[3,4],[5,6]];
         let ws=new WeakSet(a2);
         console.log(ws);*/
        // ws.forEach is not a function

• Map 数据结构存储的是 键值对
  • Map 构造函数
  • size 返回map的长度的
  • set 设置Map结构中的值的
  • get 获取Map结构中的值
  • has 检测键是否存在 返回true/false
  • delete 删除键 返回true/false
  • clear 全部清除

let obj={
            name:"张三",
            sex:"男"
        };*/
        //Map()   构造函数不传参
        let map=new Map();
        map.set("array",[1,2,3,4,5]);
        map.set("object",{name:"张三",age:20});

Map 结构中设置相同的键值的时候会覆盖

/map.set("array",[[1,2],[3,4]]);
        console.log(map.get("array"));
        console.log(map.get("object"));

        console.log(map.size);
        console.log(map.has("object"));
        console.log(map.delete("array"));
        map.clear();
        console.log(map);

    map  结构的遍历方法
    keys  方法   返回map中的所有的键   可以拆为
    values 方法  返回map中的所有的值   可以拆为数组
    entries  方法  返回map中的所有的键值对   可以拆为数组

let map=new Map();
        map.set("h1",1);
        map.set("h2","a");
        map.set("h3","b");
        map.set("h4",true);
        map.set("h5",null);
        console.log(map);
        console.log(...map.keys());
        console.log(...map.values());
        console.log(...map.entries());