ES6

1、解构 ：

数组解构：
let [a,b,c] = [1,2,3]

var a = 'hello'
var arr = [1,2,3]
var obj = {id:1}

带默认值的解构
var [a='a', arr=[], obj={}] = ['hello', [1,2,3],{id:1}]

两个值互换
let a = 1
let b = 2
[a,b] = [b, a]

...展开数组
let arr = [1,2,3]
function fn(a, b, c) {
    return a+b+c
}
fn(...arr)

对象解构：
var {a,b} = {a:1,b:2}

var res = {
    code: 200,
    result: {
        id: 1,
        age:18,
        title: 'hello',
        arr: [1,2,3,4,5]
   }
}
var {result, code} = res
var {id,title,age,arr} = result
带别名的解构
var {result:data, code:xyz} = res 
var {id:_id,title,age,arr} = data

扩展题：
var {name:n='name', age:a=1} = {age:18}
console.log(n,a) //'name',18

const fun2 = ({a=1,b=1}) => [a,b]
fun2({a:10, b:10}) // [10,10]
复制代码

2、Set

ES6提供了新的数据结构Set。它类似于数组，但是成员的值是唯一的，没有重复的值。
Set本身是一个构造函数，用来生成Set数据结构。

var set = new Set()
set.add(1)
set.add(2).add(3).add(3).add('2')
console.log(set) //Set(4) {1,2,3,'2'}

var lists = [1,2,3,4,3,2,1,4,5,7,8,9,7,4,3,5,6,8,9,5,1,3,4]
// set另一种定义方式
var s2 = new Set(lists)
console.log(s2) //Set(9) { 1, 2, 3, 4, 5, 7, 8, 9, 6 }
// 类型转换
var lists2 = Array.from(s2)
console.log(lists2)  // [ 1, 2, 3, 4, 5, 7, 8, 9, 6 ]
console.log([...s2]) // [ 1, 2, 3, 4, 5, 7, 8, 9, 6 ]

// 扩展题：
var items = [23,43,45,65,7,87,98,21,3,54,56,87,34,23,56,78,45,87,54]
// 求出大于30的数据且去重
console.log([...new Set(items.filter(v => v > 30))])
//[ 43, 45, 65, 87, 98, 54, 56, 34, 78 ]

// 对象数组去重
// 求出大于30的数据且去重
var items2 = [{v:10},{v:40},{v:56},{v:50},{v:40},{v:10},{v:50},{v:20},{v:56},{v:30},{v:60}]
var map = new Map()
var filterData = items2.filter(item => item.v > 30)
function f(arr, key) {
  for(let item of arr) {
    if(!map.has(item[key])) {
      map.set(item[key], item)
    }
  }
  return [...map.values()]
}
console.log('对象数组去重---', f(filterData, 'v'))
//[ { v: 40 }, { v: 56 }, { v: 50 }, { v: 60 } ]
复制代码

3、Map

javascript的对象（Object），本质上是键值对的集合，但是传统上只能用字符串或Symbol当作键。这给它的使用带来了很大的限制。
ES6提供了Map数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限制于字符串或Symbol，各种类型的值（包括对象）都可以当作键。

var map = new Map()
map.set('id', 10).set('name', 'ff').set('a', 'a')
console.log(map) //Map(3) { 'id' => 10, 'name' => 'ff', 'a' => 'a' }
// 另一种定义方式
var map2 = new Map([['a', 1], ['b', 2], ['c', 3]])
console.log(map2) //Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }

// for...of...
// 可以循环 Array，Set，Map，但是不能循环遍历 Object，因为对象中没有迭代器（iterator）
// 获取对象的键和值
var obj = {
  a: 1,
  b: 2,
  c: 3
}
for(let k in obj) {
  console.log(k)  //键
  console.log(obj[k]) //值
}

// 获取Map的键和值
for(let [k,v] of map2) {
  console.log(k) //键
  console.log(v) //值
}

// 对象转换Map
var map3 = new Map()
for(let k in obj) {
  map3.set(k, obj[k])
}
console.log(map3) //Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }

// Map转换对象
var obj2 = {}
for(let [k,v] of map2) {
  obj2[k] = v
}
console.log(obj2) //{ a: 1, b: 2, c: 3 }