首先再讲这几个新东西之前，先说一个Es6中新出的扩展运算符（...）
1.展开运算符，就是把东西展开，可以用在array和object上
比如：
let a=[,]
let b=[,...a,]//[0,1,2,3]
第二个是剩余操作符，是解构的一种，把剩余的东西放到一个array里面赋值给他，一般只针对array的解构
let a=[,,]
let [b,...c]=a;//b:1,c:[2,4]
let a=[,,]
let [b,...[c,d,e]]=a;//b:1,c:2,d:3,e:undefined
Symbol是一个新的基本数据类型，而且是一个值类型的
使用Symbol函数执行得到一个Symbol数据类型
Symbol跟字符串差不多，但是使用Symbol函数得到一个数据，每一个是完全不同的
Symbol可以接受一个参数（）是对这个symbol数据的描述
即使描述一样但是，值也是不同
一般当做对象的属性，任意一个Symbol（）得到的值都是不同的
let sym1=Symbol();
let sym2=Symbol();
console.log(typeof sym1);//symbol
console.log(typeof sym1);//symbol
console.log(sym1===sym2);//false
symbol值不可以跟其他值计算,即不可以转为数字，也不可以进行字符串的拼接，但是可以转为布尔值，也可以调用toString方法，显示字符串
let obj={
sym1:"jeo",[sym1]:"jack"}
console.log(obj);
obj[sym2]="rose";
console.log(obj);
console.log(Symbol("js").toString());//返回一个Symbol类型的字符串
Symbol.for()如果之前有相同参数的Symbol的值，找到这个值返回，如果没有就创建一个新的Symbol值
使用Symbol.for()参数相同，值就是相同
let s1=Symbol.for("js")
let s2=Symbol.for("js")
console.log(s1==s2);//true
Symbol.keyFor(symbol值）找到使用Symbol.for创建的值的描述
console.log(Symbol.keyFor(s1));//js
- 类似数组，只有值value，没有键key
- 通过构造函数方式创建一个Set实例（对象）
- 参数是一个数组（或者是类似数组，只是有iterable接口）
- 有iterable接口：数组，arguments，元素集合，set，map，字符串
- 默认去重
console.log(new Set([,,,]));//Set(4) {1, 2, 3, 4}
console.log(new Set(""));//Set(4) {"1", "2", "3", "4"}
function fn(){
console.log(new Set(arguments))
}
fn(,,,)//Set(4) {1, 2, 3, 4}
- size set实例大小的个数
- add（如果之前有就加上，如果没有就不增加，返回值是增加后的实例，参数默认增加一个） clear（清空，没有返回值，undefined，没有参数） delete（返回布尔值） has（判断有没有此项，返回值true／false）
//add可以实现链式写法
let set1=new Set([,,])
console.log(set1.add().add());
- forEach（遍历）
let set1=new Set([1,2,3]);
set1.forEach((...rest)=>{
console.log(rest);
})
let set1=new Set([,,]);
set1.forEach((item, index,input)=>{
//set实例只有value没有key
//item,index:当前项value
//input:当前set实例
})
- keys
let set1=new Set([1,2,3]);
for(let key of set1.keys()){
//拿到的还是value值
console.log(key);
}
- values
let set1=new Set([,,]);
for(let val of set1.values()){
console.log(val);
}
- entries（拿到的是value值）
let set1=new Set([,,]);
for(let [item,val] of set1.entries()){
//item,val都是value值
console.log(item,val); }
应用场景：
1.数组去重
let arr=[,,,,,,,,];
function arrPure(arr){
// return [...new Set(arr)];
return Array.from(new Set(arr))
}
arr=arrPure(arr);
console.log(arr);
2.求两个集合的并集
let a=[,,,,,,];
let b=[,,,,,,];
function add(a,b){
let arr=[...a,...b];
console.log(...new Set(arr));
}
add(a,b)
3.求两个集合的交集
function same(a,b){
return a.filter(item=>b.includes(time))
4.求两个集合的差集
function diff（a,b）{
return a.filter(item=>!b.includes(item))+b.filter(item=>!a.includes(item))
Map
- 构造函数创建一个Map实例,返回一个
- new Map（[[key,value],[]])
- 参数是一个数组，数组每一项也是一个数组，有两项key，value
- 一个对象 属性名必须是字符串，如果你写的不是字符串也默认转为字符串
let ary=[1,2],o={};
let obj={
name:'jeo',
ary,
[o]:o,
}
console.log(obj)
/**
*{name: "jeo", ary: Array(2), [object Object]: {…}}
[object Object]: {}
ary: (2) [1, 2]
name: "jeo"
__proto__: Object
*/
- Map实例的key可以是任意数据类型
let m1=new Map([[1,"jeo"],[true,'rose'],[{name:"jack"},{name:23}]])
console.log(m1)
size：键值对的个数
let m1=new Map([[,"jeo"],[true,'rose'],[{name:"jack"},{name:}]])
m1.get()//jeo
get（获取值)，set（可以实现链式写法），has判断key有没有对应的value，有就是true，没有就是false
let m1=new Map([[1,"jeo"],[true,'rose'],[{name:"jack"},{name:23}]])
m1.forEach((key,value,input)=>
{
console.log(key)
console.log(value)
console.log(input)
})//key是属性名，value是属性值，input是Map实例
给定一个数组变成Map实例
let arr=['js','vue','react','node']
let m1=new Map();
for(let [index,item] arr.entries()){
m1.set(index, item)}
console.log(m1);/*Map(4) {0 => "js", 1 => "vue", 2 => "react", 3 => "node"}
size: (...)
__proto__: Map
[[Entries]]: Array(4)
0: {0 => "js"}
1: {1 => "vue"}
2: {2 => "react"}
3: {3 => "node"}
length: 4
*/
map（）：
map和forEach等遍历方法不同，在forEach中return语句是没有任何效果的，而map则可以改变当前循环的值，返回一个新的被改变过值之后的数组，一般用来处理需要修改某一个数组的值
filter用于吧Array的某些元素过滤掉，然后返回剩下的元素（filert（）接收一个函数，把传入的函数依次作用域每个元素，然后在根据返回值是true还是false决定保留还是丢弃元素）
- 用filter选择数组中的奇数
function filterUse(){
let arr=[,,,,,];
var r=arr.filter(x=>x%!==)
console.log(r);
}
filterUse();
- 利用filter实现去除重复元素，思想是：indexOf总是返回第一个元素的位置，后续的重复元素位置与indexOf返回的位置不相等，因此被filter滤掉了。
function filterUse(){
let arr=[1,2,3,7,9,3];
let r=arr.filter(function(element,index,self){
return self.indexOf(element)===index;
})
console.log(r);
}
filterUse();
