test

简介

ES6(2015),ECMAScript6.0,是JavaScript的 下一个版本标准。JavaScript是ECMAScript的实现,ECMAScript是JavaScript的标准。javascript

let 和 const

  • let声明的变量只在let命令所在的代码块中有效
  • const声明一个只读常亮,一旦声明不能再被更改

let代码块中有效,var全局范围内有效且存在变量提高(即定义在后面的变量,前面能够访问到).html

{
    var a = 3;/*全局都共享*/
    let b = 2;/*被限定在代码块中*/
}
console.log(a);/*3*/
//console.log(b);/*Uncaught ReferenceError: a is not defined*/

const声明一个只读变量,声明以后不容许修改,必须初始化。java

{
    const PI = 3.14;
    /*编译器直接报错*/
    PI = 3.15;/*attempt to assign to const or readonly variable*/
    console.log(PI);
}

注:这里的常量保证的只是地址不变,若是是基本类型,则保证数据不变;但若是是对象,只是保证对象的引用地址不变,对象里面的属性值依然能够改变数组

{
    const person={
        name:"wade",
        age:20
    }
    person.name="peter";
    console.log(person);/*{name: "peter", age: 20}*/
    console.log(person.name);/*peter*/
}

解构函数

针对数组或者对象进行模式匹配,而后对其中的变量进行赋值。函数

解构的源=解构的目标 ,注意:左右解构要同样code

数组(Array)

  1. 左右映射,对应orm

    //基本
    {
        let [a, b, c] = [1, 2, 3];
        console.log(a, b, c)//1 2 3
    }
    //嵌套
    {
        let [a, [b, c]] = [3, [5, 7]];
        console.log(a, b, c)//3 5 7
    }
    
    //忽略
    {
        let [a, , b, c,] = [1, 3, 5, 6, 7];
        console.log(a, b, c)//1 5 6
    }
    1. 默认值,没有对应的能够给默认值htm

      {
          let [a = 1, b] = [, 10];
          console.log(a,b)//1 10
      }
    2. 剩余运算符对象

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

    对象(Object)

    对象解构与数组解构相似,注意{}与[]区别,左右对应便可,能匹配上就是右边的值,不能匹配上就是undefined。blog

    {
        let {name, age} = {name: 'wade', age: 18};
        console.log(name, age)//wade 18
    }
    
    {
        let {name,...other}={name:'wade',age:12,sex:'male',height:'150'}
        console.log(name)//wade
        console.log(other)//{age: 12, sex: "male", height: "150"}
    }

Symbol

定义一种新的类型,表示独一无二的值,最大的用法用来定义惟一的属性名。

ES6 数据类型除了 Number 、 String 、 Boolean 、 Object、 null 和 undefined ,还新增了 Symbol 。

用法

  • Symbol 函数栈不能用 new 命令,由于 Symbol 是原始数据类型,不是对象。能够接受一个字符串做为参数,为新建立的 Symbol 提供描述,用来显示在控制台或者做为字符串的时候使用,便于区分。
{
    let str1 = Symbol("abc");
    console.log(str1)//Symbol(abc)
    console.log(typeof(str1));symbol

    let str2 =Symbol("abc");
    console.log(str1 == str2)//false
}

做为属性名,保证属性不重名

let name = Symbol("name");
let age = Symbol("age");
{
    let obj = {
        [name]: "wade",
        [age]: 18
    }
    console.log(obj[name],obj[age])//wade 18
    console.log(obj.name)//undefined
}

注:只能经过obj[symbolName]去取值,不能经过点。

Map 与 Set

Map

Map 对象保存键值对。任何值(对象或者原始值) 均可以做为一个键或一个值。

map.set(key:any,value:any)

Maps 和 Objects 的区别

  • 一个 Object 的键只能是字符串或者 Symbols,但一个 Map 的键能够是任意值。
  • Map 中的键值是有序的(FIFO 原则),而添加到对象中的键则不是。
  • Map 的键值对个数能够从 size 属性获取,而 Object 的键值对个数只能手动计算。
  • Object 都有本身的原型,原型链上的键名有可能和你本身在对象上的设置的键名产生冲突。

用法:

{
    let map = new Map();
    let str = "key1";
    map.set(str, "123");
    let obj = {};
    map.set(obj, {name: 10});
    let bool = true;
    map.set(bool, 123);
    let boo=true;
    map.set(boo,234);//当map中存在此key时,会将原来的值替换

    console.log(map.get(str))//123
    console.log(map.get(obj))//{name:10}
    console.log(map.get(bool))//234
    console.log(map.get(boo))//234
}

for ... of 遍历

//for...of
for (let [key, val] of map) {
    console.log(key, val)
}

for (let [key,val] of map.entries()){
    console.log(key,val);
}

for (let key of map.keys()){
    console.log(key)
}

for (let val of map.values()){
    console.log(val)
}

forEach

map.forEach(function (val, key) {
    console.log(val,key)
})

Map <-----> Array

{
    let map=new Map();
    map.set("k1","wade");
    map.set("k2","peter");

    //map to array
    let arr = Array.from(map);
     /*
     (2) [Array(2), Array(2)]
          0: (2) ["k1", "wade"]
          1: (2) ["k2", "peter"]*/
    console.log(arr)
    //array to map
    let mapFormArr = new Map(arr);
    
    /*
    Map(2) {"k1" => "wade", "k2" => "peter"}
        [[Entries]]
        0: {"k1" => "wade"}
        1: {"k2" => "peter"}
    * */
    console.log(mapFormArr)
}

Set

Set 对象容许你存储任何类型的惟一值,不管是原始值或者是对象引用。

Set 中的特殊值

Set 对象存储的值老是惟一的,因此须要判断两个值是否恒等。有几个特殊值须要特殊对待:

  • +0 与 -0 在存储判断惟一性的时候是恒等的,因此不重复;
  • undefined 与 undefined 是恒等的,因此不重复;
  • NaN 与 NaN 是不恒等的,可是在 Set 中只能存一个,不重复。
{
    let set = new Set();
    set.add(1);
    set.add("a");
    set.add("a");
    set.add({name: "wade"})


    console.log(set)//Set(3) {1, "a", {…}}
}

集合操做详情

相关文章
相关标签/搜索
本站公众号
   欢迎关注本站公众号,获取更多信息