Set 对象

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。

Set 中的特殊值

Set 对象存储的值总是唯一的，所以需要判断两个值是否恒等。有几个特殊值需要特殊对待：

  • +0 与 -0 在存储判断唯一性的时候是恒等的，所以不重复；
  • undefined 与 undefined 是恒等的，所以不重复；
  • NaN 与 NaN 是不恒等的，但是在 Set 中只能存一个，不重复。

Set声明

const set = new Set()

 

Set属性

  • size：返回 Set 对象中值的数量

 

Set方法

  • add(value): 在Set对象尾部添加一个元素，返回该Set对象。
  • delete(value): 移除Set的中与这个值相等的元素，有则返回true，无则返回false。
  • clear(): 清楚Set的所有元素。
  • has(value): 是否存在这个值，如果存在为 true，否则为false。
  • keys()：返回键名的遍历器。
  • values()：返回键值的遍历器。
  • entries()：返回键值对的遍历器。
  • forEach()：使用回调函数遍历每个成员。

 Set方法使用：

let mySet = new Set()

	//add()
	mySet.add('1')
	mySet.add(1)
	console.log(mySet) // Set(2) {1, "1"}

	//size
	console.log(mySet.size) // 2

	//delete()
	mySet.delete('1')
	console.log(mySet) // Set(1) {1}

	//has()
	console.log(mySet.has(1)) // true
	console.log(mySet.has(2)) // false

	//clear()
	mySet.clear()
	console.log(mySet) // Set(0) {}

	let arr = [{id: 1}, {id: 2}, {id: 3}]
	let mySet1 = new Set(arr)

	// keys()
	for (let key of mySet1.keys()) {
		console.log('key:', key); // key:{id: 1} key:{id: 2} key:{id: 3}
	}

	//values()
	for (let key of mySet1.values()) {
		console.log('values:', key); // values:{id: 1} values:{id: 2} values:{id: 3}
	}

	//entries()
	for (let data of mySet1.entries()) {
		console.log('entries:',	data); // entries:[{id: 1},{id: 1}] entries:[{id: 2},{id: 2}] entries:[{id: 3},{id: 3}]
	}

	//forEach
	mySet1.forEach((item) => {
		console.log('forEach:', item) // forEach:{id: 1} forEach:{id: 2} forEach:{id: 3}
	});

 

Set对象应用

// 数组去重
var mySet = new Set([1, 2, 3, 4, 4]);
[...mySet]; // [1, 2, 3, 4]

// 字符串去重
[...new Set('ababbc')].join('')  // "abc"

 let a = new Set([1, 2, 3])
 let b = new Set([2, 4, 3])
 
//并集
let union = new Set([...a, ...b]))  // {1, 2, 3, 4}
 
//交集
let intersect  = new Set([...a].filter(x => b.has(x))) // {2, 3}
 
// 差集
// （a 相对于 b 的）差集
let difference = new Set([...a].filter(x => !b.has(x))) // {1}

// 映射
// 方法一
let set = new Set([1, 2, 3]);
set = new Set([...set].map(val => val * 2));
// set的值是2, 4, 6

// 方法二
let set = new Set([1, 2, 3]);
set = new Set(Array.from(set, val => val * 2));
// set的值是2, 4, 6

 

 

Map 对象

Map 对象保存键值对。任何值(对象或者原始值) 都可以作为一个键或一个值。

Map属性

  • size：返回 Map 结构的成员总数。

Map方法

  • set(key,value): 设置键名key对应的键值为value的键值对，若key已存在，更新键值。
  • get(key): 返回key对应的值。
  • delete(key): 移除Map的中与这个值相等的元素，有则返回true，无则返回false。
  • clear(): 清除所有成员，没有返回值。
  • has(key): 是否存在这个值，如果存在为 true，否则为false。
  • keys()：返回键名的遍历器。
  • values()：返回键值的遍历器。
  • entries()：返回所有成员的遍历器。
  • forEach()：遍历 Map 的所有成员。
let myMap = new Map()

	//set(key,value)
	myMap.set('a', 1)
	myMap.set('b', 2)
	console.log(myMap) // Map(2) {'a' => 1, 'b' => 2}

	//get(key)
	console.log(myMap.get('a')) // 1

	myMap.set('a', 3)
	console.log(myMap.get('a')) // 3  同一个键多次赋值，后面的值将覆盖前面的值。

	//size
	console.log(myMap.size) // 2

	//delete(key)
	myMap.delete('a') // true
	console.log(myMap) // Map(1) {'b' => 2}

	//has(key)
	console.log(myMap.has('b')) // true
	console.log(myMap.has(1)) // false

	//clear()
	myMap.clear()
	console.log(myMap) // Map(0) {}

	let arr = [['a', 1],['b', 2],['c', 3]]
	let myMap1 = new Map(arr)

	// keys()
	for (let key of myMap1.keys()) {
		console.log('keys:', key); // keys:a keys:b keys:c
	}

	//values()
	for (let value of myMap1.values()) {
		console.log('values:', value); // values:1 values:2 values:3
	}

	//entries()
	for (let data of myMap1.entries()) {
		console.log('entries:', data); // entries:["a", 1] entries:["b", 2] entries:["c", 3]
	}

	//forEach
	myMap1.forEach((item) => {
		console.log('forEach:',item) // forEach:1 forEach:2 forEach:3
	});

 

与其他数据结构的互相转换

（1）Map 转为数组

使用扩展运算符（...）。

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

 

（2）数组 转为 Map

将数组传入 Map 构造函数，就可以转为 Map。

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

 

（3）Map 转为对象

如果所有 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)
// { yes: true, no: false }

如果有非字符串的键名，那么这个键名会被转成字符串，再作为对象的键名。

 

（4）对象转为 Map

对象转为 Map 可以通过Object.entries()。

let obj = {"a":1, "b":2};
let map = new Map(Object.entries(obj));

 

此外，也可以自己实现一个转换函数。

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 {"yes" => true, "no" => false}

 

（5）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"]]]'

 

（6）JSON 转为 Map

JSON 转为 Map，正常情况下，所有键名都是字符串。

function jsonToStrMap(jsonStr) {
  return objToStrMap(JSON.parse(jsonStr));
}

jsonToStrMap('{"yes": true, "no": false}')
// Map {'yes' => true, 'no' => false}

 

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

function jsonToMap(jsonStr) {
  return new Map(JSON.parse(jsonStr));
}

jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
// Map {true => 7, Object {foo: 3} => ['abc']}