es6中map和set

1. set

ES6 提供了新的数据结构 Set。它类似于数组,但是成员的值都是唯一的,没有重复的值。

Set 本身是一个构造函数,用来生成 Set 数据结构 。

const s = new Set();  
  
[2, 3, 5, 4, 5, 2, 2].forEach(x => s.add(x));  
  
for (let i of s) {  
  console.log(i);  
}  
// 2 3 5 4  

上面代码通过add方法向 Set 结构加入成员,结果表明Set 结构不会添加重复的值。

// 例一  
const set = new Set([1, 2, 3, 4, 4]);  
[...set]  
// [1, 2, 3, 4]  
  
// 例二  
const items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);  
items.size // 5  
 

上面代码中,也展示了一种去除数组重复成员的方法s

// 去除数组的重复成员  
[...new Set(array)]  

还有一种函数法数组去重

function dedupe(array) {  
  return Array.from(new Set(array));  
}  
  
dedupe([1, 1, 2, 3]) // [1, 2, 3]  

Set 实例的方法分为两大类:操作方法(用于操作数据)和遍历方法(用于遍历成员)。下面先介绍四个操作方法。

  • add(value):添加某个值,返回Set结构本身。
  • delete(value):删除某个值,返回一个布尔值,表示删除是否成功。
  • has(value):返回一个布尔值,表示该值是否为Set的成员。
  • clear():清除所有成员,没有返回值。
s.add(1).add(2).add(2);  
// 注意2被加入了两次  
  
s.size // 2  
  
s.has(1) // true  
s.has(2) // true  
s.has(3) // false  
  
s.delete(2);  
s.has(2) // false  

Set 结构的实例有四个遍历方法,可以用于遍历成员。

  • keys():返回键名的遍历器
  • values():返回键值的遍历器
  • entries():返回键值对的遍历器
  • forEach():使用回调函数遍历每个成员
(1)keys(),values(),entries()

由于 Set 结构没有键名,只有键值(或者说键名和键值是同一个值),所以keys方法和values方法的行为完全一致。

let set = new Set(['red', 'green', 'blue']);  
  
for (let item of set.keys()) {  
  console.log(item);  
}  
// red  
// green  
// blue  
  
for (let item of set.values()) {  
  console.log(item);  
}  
// red  
// green  
// blue  
  
for (let item of set.entries()) {  
  console.log(item);  
}  
// ["red", "red"]  
// ["green", "green"]  
// ["blue", "blue"] 
(2)forEach()

Set结构的实例的forEach方法,用于对每个成员执行某种操作,没有返回值。

let set = new Set([1, 2, 3]);  
set.forEach((value, key) => console.log(value * 2) )  
// 2  
// 4  
// 6  
(3)遍历的应用

扩展运算符(...)内部使用for...of循环,所以也可以用于 Set 结构。

let set = new Set(['red', 'green', 'blue']);  
let arr = [...set];  
// ['red', 'green', 'blue'] 
let arr = [3, 5, 2, 2, 5, 5];  
let unique = [...new Set(arr)];  
// [3, 5, 2]  

而且,数组的map和filter方法也可以用于 Set 了。

let set = new Set([1, 2, 3]);  
set = new Set([...set].map(x => x * 2));  
// 返回Set结构:{2, 4, 6}  
  
let set = new Set([1, 2, 3, 4, 5]);  
set = new Set([...set].filter(x => (x % 2) == 0));  
// 返回Set结构:{2, 4}  

因此使用 Set 可以很容易地实现并集(Union)、交集(Intersect)和差集(Difference)。

let a = new Set([1, 2, 3]);  
let b = new Set([4, 3, 2]);  
  
// 并集  
let union = new Set([...a, ...b]);  
// Set {1, 2, 3, 4}  
  
// 交集  
let intersect = new Set([...a].filter(x => b.has(x)));  
// set {2, 3}  
  
// 差集  
let difference = new Set([...a].filter(x => !b.has(x)));  
// Set {1}  

如果想在遍历操作中,同步改变原来的 Set 结构,目前没有直接的方法,但有两种变通方法。一种是利用原 Set 结构映射出一个新的结构,然后赋值给原来的 Set 结构;另一种是利用Array.from方法。

2. Map

Set类似于数组,而Map就类似于键值对(Key, Value);
ES6 提供了 Map 数据结构。它类似于对象,也是键值对的集合,但是“键”的范围不限于字符串,各种类型的值(包括对象)都可以当作键。

const map = new Map([  
  ['name', '张三'],  
  ['title', 'Author']  
]);  
  
map.size // 2  
map.has('name') // true  
map.get('name') // "张三"  
map.has('title') // true  
map.get('title') // "Author" 

上面代码在新建 Map 实例时,就指定了两个键name和title。

Map构造函数接受数组作为参数,实际上执行的是下面的算法。

const items = [  
  ['name', '张三'],  
  ['title', 'Author']  
];  
  
const map = new Map();  
  
items.forEach(  
  ([key, value]) => map.set(key, value)  
);  

如果 Map 的键是一个简单类型的值(数字、字符串、布尔值),则只要两个值严格相等,Map 将其视为一个键,包括0和-0,布尔值true和字符串true则是两个不同的键。另外,undefined和null也是两个不同的键。虽然NaN不严格相等于自身,但 Map 将其视为同一个键。

let map = new Map();  
  
map.set(-0, 123);  
map.get(+0) // 123  
  
map.set(true, 1);  
map.set('true', 2);  
map.get(true) // 1  
  
map.set(undefined, 3);  
map.set(null, 4);  
map.get(undefined) // 3  
  
map.set(NaN, 123);  
map.get(NaN) // 123  
Map有size()属性,查看Map对象大小,set(key , value) , get(Key), delete(key) , has(key) ,clear()方法。

遍历方法
Map 结构原生提供三个遍历器生成函数和一个遍历方法。

  • keys():返回键名的遍历器。
  • values():返回键值的遍历器。
  • entries():返回所有成员的遍历器。
  • forEach():遍历 Map 的所有成员。
    需要特别注意的是,Map 的遍历顺序就是插入顺序。
const map = new Map([  
  ['F', 'no'],  
  ['T',  'yes'],  
]);  
  
for (let key of map.keys()) {  
  console.log(key);  
}  
// "F"  
// "T"  
  
for (let value of map.values()) {  
  console.log(value);  
}  
// "no"  
// "yes"  
  
for (let item of map.entries()) {  
  console.log(item[0], item[1]);  
}  
// "F" "no"  
// "T" "yes"  
  
// 或者  
for (let [key, value] of map.entries()) {  
  console.log(key, value);  
}  
// "F" "no"  
// "T" "yes"  
  
// 等同于使用map.entries()  
for (let [key, value] of map) {  
  console.log(key, value);  
}  
// "F" "no"  
// "T" "yes"  

Map 结构转为数组结构,比较快速的方法是使用扩展运算符(...)。

const map = new Map([  
  [1, 'one'],  
  [2, 'two'],  
  [3, 'three'],  
]);  
  
[...map.keys()]  
// [1, 2, 3]  
  
[...map.values()]  
// ['one', 'two', 'three']  
  
[...map.entries()]  
// [[1,'one'], [2, 'two'], [3, 'three']]  
  
[...map]  
// [[1,'one'], [2, 'two'], [3, 'three']]

结合数组的map方法、filter方法,可以实现 Map 的遍历和过滤(Map 本身没有map和filter方法)。

const map0 = new Map()  
  .set(1, 'a')  
  .set(2, 'b')  
  .set(3, 'c');  
  
const map1 = new Map(  
  [...map0].filter(([k, v]) => k < 3)  
);  
// 产生 Map 结构 {1 => 'a', 2 => 'b'}  
  
const map2 = new Map(  
  [...map0].map(([k, v]) => [k * 2, '_' + v])  
    );  
// 产生 Map 结构 {2 => '_a', 4 => '_b', 6 => '_c'} 

结合数组的map方法、filter方法,可以实现 Map 的遍历和过滤(Map 本身没有map和filter方法)。

const map0 = new Map()  
  .set(1, 'a')  
  .set(2, 'b')  
  .set(3, 'c');  
  
const map1 = new Map(  
  [...map0].filter(([k, v]) => k < 3)  
);  
// 产生 Map 结构 {1 => 'a', 2 => 'b'}  
  
const map2 = new Map(  
  [...map0].map(([k, v]) => [k * 2, '_' + v])  
    );  
// 产生 Map 结构 {2 => '_a', 4 => '_b', 6 => '_c'}  

Map可以跟数组,对象,JSON相互转换,这里记录一下与JSON的转换

--Map 转为 JSON
Map 转为 JSON 要区分两种情况。一种情况是,Map 的键名都是字符串,这时可以选择转为对象 JSON。
function strMapToJson(strMap) {  
  return JSON.stringify(strMapToObj(strMap));  
}  
  
let myMap = new Map().set('yes', true).set('no', false);  
strMapToJson(myMap)  
// '{"yes":true,"no":false}'  
另一种情况是,Map 的键名有非字符串,这时可以选择转为数组 JSON。
function mapToArrayJson(map) {  
  return JSON.stringify([...map]);  
}  
  
let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);  
mapToArrayJson(myMap)  
// '[[true,7],[{"foo":3},["abc"]]]'
--JSON 转为 Map
JSON 转为 Map,正常情况下,所有键名都是字符串。
function jsonToStrMap(jsonStr) {  
  return objToStrMap(JSON.parse(jsonStr));  
}  
  
jsonToStrMap('{"yes": true, "no": false}')  
// Map {'yes' => true, 'no' => false}  

但是,有一种特殊情况,整个 JSON 就是一个数组,且每个数组成员本身,又是一个有两个成员的数组。这时,它可以一一对应地转为Map。这往往是数组转为 JSON 的逆操作。

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

WeakSet和WeakMap适用于防止内存泄漏,这里不做说明。

你可能感兴趣的:(es6中map和set)