ES6中Set,Map数据结构

原生的数组去重：

var a = Array.from(new Array(1000000), (x, index)=>{
  return index;
})
var b = Array.from(new Array(1000000), (x, index)=>{
  return index;
})
a = a.concat(b);

方案一：优化遍历数组法 , 实现思路：获取没重复的最右一值放入新数组。
function unique (array) {
    var temp = [];
    var len = array.length;
    for (var i = 0; i < len; i++) {
        for (var j = i + 1; j < len; j++) {
            if (array[i] == array[j]) {
                i++;
                j = i;   
            }
        }
        temp.push(array[i]);
    }
    return temp;
}

unique(a);



方案二：
function distinct(arr) {
  let result = [],
    obj = {},
    len = arr.length,
    i = 0;

  for (; i < len; i++) {
    var item = arr[i];
    if (!obj[item]) {
      result.push(item)
      obj[item] = 1;
    }
  }
  
  return result;
}
distinct(a)

方案三：[...new Set(a)]


当重复值少的时候，第一个方案耗时最久（17093），第二方案（20），第三方案（25）。
把返回改成
b: return index % 3;
a: return index % 4;
当重复值多的时候，第一方案（3），第二方案（11），第三方案（2）.

重复值越少方案一越慢，不适用。


数组项全部重复的时候：方案二（35）， 方案三（22）；
数组项全部不重复： 方案二（222）， 方案三（550）;

数组的去重：

[...new Set(array)]

Array.from(new Set(array))

 

字符串的去重：

[...new Set(string)].join('')

数组的并集：

[...new Set([...array1, ...array2])]

数组的交集：

[...new Set(array1.filter(x => new Set(array2).has(x)))]

数组的差集：

[...new Set(array1.filter(x => !new Set(array2).has(x)))]

声明变量的方式：

var, function, let, const, class, import

WeakSet 的一个用处，是储存 DOM 节点，而不用担心这些节点从文档移除时，会引发内存泄漏。

 

Map的去重：

const s1 = new Set([
  ['key', 1],
  ['key', 2]
]);
const m1 = new Map(s1);

// key: "foo", value: 2
// m1.size: 1

Map 转为数组:

const myMap = new Map()
  .set(true, 7)
  .set({foo: 3}, ['abc']);
[...myMap]

数组 转为 Map:

new Map([
  [true, 7],
  [{foo: 3}, ['abc']]
])

Map 转为对象:

function strMapToObj(strMap) {
  let obj = Object.create(null);
  for (let [k,v] of strMap) {
    obj[k] = v;
  }
  return obj;
}

const myMap = new Map()
  .set('yes', true)
  .set('no', false);
strMapToObj(myMap)

对象转为 Map:

function objToStrMap(obj) {
  let strMap = new Map();
  for (let k of Object.keys(obj)) {
    strMap.set(k, obj[k]);
  }
  return strMap;
}

objToStrMap({yes: true, no: false})

Map 转为 JSON:

// 一
function strMapToJson(strMap) {
  return JSON.stringify(strMapToObj(strMap));
}
let myMap = new Map().set('yes', true).set('no', false);
strMapToJson(myMap)


// 二
function mapToArrayJson(map) {
  return JSON.stringify([...map]);
}
let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
mapToArrayJson(myMap)

JSON 转为 Map：

// 一
function jsonToStrMap(jsonStr) {
  return objToStrMap(JSON.parse(jsonStr));
}
jsonToStrMap('{"yes": true, "no": false}')


// 二
function jsonToMap(jsonStr) {
  return new Map(JSON.parse(jsonStr));
}
jsonToMap('[[true,7],[{"foo":3},["abc"]]]')