1、数据解构赋值
1、数组的解构赋值
基本用法:let [key1,key2…]=[value1,value2…]

let [name,age,sex]=['小明',24,'男'];
console.log(name);
console.log(age);
console.log(sex);
    注意左右的key与value格式要匹配对应,键值可以缺省,但逗号的位置要正确

let [arr1,,[arr3,,[,arr6]]]=[1,2,[31,32,[331,332]]];
console.log(arr1);
console.log(arr3);
console.log(arr6);

2、对象的解构赋值

    用法:let  {key1,key2...}={key1:value1,key2:value2...}   

let obj={name:'小明',age:24,sex:'男',friend:['小张','小李']};
console.log(obj.name);
console.log(obj.age);
console.log(obj.sex);
console.log(obj.friend);

3、字符串类型

    字符串中每个字符与数组键对应

let [a,b,c]="这是一个字符串";
console.log(a);
console.log(b);
console.log(c);

2、新增数据类型Set集合
set与数组不同在于set中不可以有重复数据,常用于去重操作
1、创建set

let myset=new Set([‘data1’,’data2’,’data3’,’data3’]);
2、属性size:集合的元素个数

console.log(myset.size);
3、方法

myset.add('data4');//增加元素
myset.delete('data2');//删除元素
console.log(myset.has('data1'));//判断是否含有某个元素,包含返回true
myset.clear();//清除集合所有元素
console.log(myset.keys());//返回集合所有的键值
console.log(myset.values());//返回集合所有值

3、新增数据类型Map
由于对象的键值只能是字符串,不可以是对象类型,使用对象作为键值会被toString转化为字符串”[object Object]”,例如:

let obj1={key:1},obj2={key:2},obj={};
obj.value='objValue';
obj[obj1]='obj1Value';    //将对象obj1作为obj的键值
obj[obj2]='obj2Value';
console.log(obj);
输出:Object { value: "objValue", "[object Object]": "obj2Value" },由于转化为相同的键值字符串,obj2会覆盖obj1

而使用map可以避免键值必须为字符串的限制,其键值可以为对象、数组等

1、创建Map

let mymap=new Map([
    ['stringKey','stringValue'],
    ['age',24],
    [obj1,'obj1Value'],
    [obj2,'obj2Value'],
    [['arr'],'arrValue']
]);
打印mymap如下:

2、属性size:返回map中键值对个数

console.log(mymap.size);
3、方法

mymap.set('key','value');//设置map的键、值
mymap.get('key');//通过键来取值
mymap.delete('key');//删除对应的键值
mymap.has('key');//判断是否含有
//mymap.clear();//清除map中所有键值
//遍历
mymap.forEach(function (value,key) {
    console.log(key+":"+value);
})

4、注意{}与{}是不同的两个键值

mymap.set({},"obj1");
mymap.set({},"obj2");
以上语句obj2不会覆盖obj1,由于空对象{}在内存中不同的堆区申请存储空间,所以作为键值它们是不同的

4、Symbol类型
在用相同的字符串对对象属性名或方法进行命名时会发生命名冲突,而使用symbol产生的名字是不同的,例如:

let obj={};
obj[Symbol('name')]="小赵";
obj[Symbol('name')]="小钱";
console.log(obj);
结果如下,不会覆盖第一句:

5、Symbol应用场景
ES6中引入了一种新的基础数据类型:Symbol,不过很多开发者可能都不怎么了解它,或者觉得在实际的开发工作中并没有什么场景应用到它,那么今天我们来讲讲这个数据类型,并看看我们怎么来利用它来改进一下我们的代码。
这是一种新的基础数据类型(primitive type)
Symbol是由ES6规范引入的一项新特性,它的功能类似于一种标识唯一性的ID。通常情况下,我们可以通过调用Symbol()函数来创建一个Symbol实例:
let s1 = Symbol()

或者,你也可以在调用Symbol()函数时传入一个可选的字符串参数,相当于给你创建的Symbol实例一个描述信息:
let s2 = Symbol(‘another symbol’)

如果用当下比较流行的TypeScript的方式来描述这个Symbol()函数的话,可以表示成:
/**

  • @param {any} description 描述信息。可以是任何可以被转型成字符串的值,如:字符串、数字、对象、数组等
    */
    function Symbol(description?: any): symbol

由于Symbol是一种基础数据类型,所以当我们使用typeof去检查它的类型的时候,它会返回一个属于自己的类型symbol,而不是什么string、object之类的:
typeof s1 // ‘symbol’

另外,我们需要重点记住的一点是:每个Symbol实例都是唯一的。因此,当你比较两个Symbol实例的时候,将总会返回false:
let s1 = Symbol()
let s2 = Symbol(‘another symbol’)
let s3 = Symbol(‘another symbol’)

s1 === s2 // false
s2 === s3 // false

应用场景1:使用Symbol来作为对象属性名(key)
在这之前,我们通常定义或访问对象的属性时都是使用字符串,比如下面的代码:
let obj = {
abc: 123,
“hello”: “world”
}

obj[“abc”] // 123
obj[“hello”] // ‘world’

而现在,Symbol可同样用于对象属性的定义和访问:
const PROP_NAME = Symbol()
const PROP_AGE = Symbol()

let obj = {
[PROP_NAME]: “一斤代码”
}
obj[PROP_AGE] = 18

obj[PROP_NAME] // ‘一斤代码’
obj[PROP_AGE] // 18

随之而来的是另一个非常值得注意的问题:就是当使用了Symbol作为对象的属性key后,在对该对象进行key的枚举时,会有什么不同?在实际应用中,我们经常会需要使用Object.keys()或者for…in来枚举对象的属性名,那在这方面,Symbol类型的key表现的会有什么不同之处呢?来看以下示例代码:
let obj = {
[Symbol(‘name’)]: ‘一斤代码’,
age: 18,
title: ‘Engineer’
}

Object.keys(obj) // [‘age’, ‘title’]

for (let p in obj) {
console.log(p) // 分别会输出:’age’ 和 ‘title’
}

Object.getOwnPropertyNames(obj) // [‘age’, ‘title’]

由上代码可知,Symbol类型的key是不能通过Object.keys()或者for…in来枚举的,它未被包含在对象自身的属性名集合(property names)之中。所以,利用该特性,我们可以把一些不需要对外操作和访问的属性使用Symbol来定义。
也正因为这样一个特性,当使用JSON.stringify()将对象转换成JSON字符串的时候,Symbol属性也会被排除在输出内容之外:
JSON.stringify(obj) // {“age”:18,”title”:”Engineer”}

我们可以利用这一特点来更好的设计我们的数据对象,让“对内操作”和“对外选择性输出”变得更加优雅。
然而,这样的话,我们就没办法获取以Symbol方式定义的对象属性了么?非也。还是会有一些专门针对Symbol的API,比如:
// 使用Object的API
Object.getOwnPropertySymbols(obj) // [Symbol(name)]

// 使用新增的反射API
Reflect.ownKeys(obj) // [Symbol(name), ‘age’, ‘title’]

应用场景2:使用Symbol来替代常量
先来看一下下面的代码,是不是在你的代码里经常会出现?
const TYPE_AUDIO = ‘AUDIO’
const TYPE_VIDEO = ‘VIDEO’
const TYPE_IMAGE = ‘IMAGE’

function handleFileResource(resource) {
switch(resource.type) {
case TYPE_AUDIO:
playAudio(resource)
break
case TYPE_VIDEO:
playVideo(resource)
break
case TYPE_IMAGE:
previewImage(resource)
break
default:
throw new Error(‘Unknown type of resource’)
}
}

如上面的代码中那样,我们经常定义一组常量来代表一种业务逻辑下的几个不同类型,我们通常希望这几个常量之间是唯一的关系,为了保证这一点,我们需要为常量赋一个唯一的值(比如这里的’AUDIO’、’VIDEO’、 ‘IMAGE’),常量少的时候还算好,但是常量一多,你可能还得花点脑子好好为他们取个好点的名字。
现在有了Symbol,我们大可不必这么麻烦了:
const TYPE_AUDIO = Symbol()
const TYPE_VIDEO = Symbol()
const TYPE_IMAGE = Symbol()

这样定义,直接就保证了三个常量的值是唯一的了!是不是挺方便的呢。
应用场景3:使用Symbol定义类的私有属性/方法
我们知道在JavaScript中,是没有如Java等面向对象语言的访问控制关键字private的,类上所有定义的属性或方法都是可公开访问的。因此这对我们进行API的设计时造成了一些困扰。
而有了Symbol以及模块化机制,类的私有属性和方法才变成可能。例如:

在文件 a.js中

const PASSWORD = Symbol()

class Login {
constructor(username, password) {
this.username = username
this[PASSWORD] = password
}

checkPassword(pwd) {
return this[PASSWORD] === pwd
}
}

export default Login

在文件 b.js 中

import Login from ‘./a’

const login = new Login(‘admin’, ‘123456’)

login.checkPassword(‘123456’) // true

login.PASSWORD // oh!no!
login[PASSWORD] // oh!no!
login[“PASSWORD”] // oh!no!

由于Symbol常量PASSWORD被定义在a.js所在的模块中,外面的模块获取不到这个Symbol,也不可能再创建一个一模一样的Symbol出来(因为Symbol是唯一的),因此这个PASSWORD的Symbol只能被限制在a.js内部使用,所以使用它来定义的类属性是没有办法被模块外访问到的,达到了一个私有化的效果。
注册和获取全局Symbol
通常情况下,我们在一个浏览器窗口中(window),使用Symbol()函数来定义和Symbol实例就足够了。但是,如果你的应用涉及到多个window(最典型的就是页面中使用了iframe),并需要这些window中使用的某些Symbol是同一个,那就不能使用Symbol()函数了,因为用它在不同window中创建的Symbol实例总是唯一的,而我们需要的是在所有这些window环境下保持一个共享的Symbol。这种情况下,我们就需要使用另一个API来创建或获取Symbol,那就是Symbol.for(),它可以注册或获取一个window间全局的Symbol实例:
let gs1 = Symbol.for(‘global_symbol_1’) //注册一个全局Symbol
let gs2 = Symbol.for(‘global_symbol_1’) //获取全局Symbol

gs1 === gs2 // true

这样一个Symbol不光在单个window中是唯一的,在多个相关window间也是唯一的了。
好了,通过以上这些例子,你现在是不是开始对ES6的这个Symbol功能有点了解了呢?Symbol在JS内部也有很多应用,比如迭代器(Iterator)等,大家可以以此为出发点,发掘出更多相关知识点,深入的理解Symbol的用法和使用场景。