Set和Map数据结构

Set

1.set类似于数组，但是成员的值不重复
2.实例化set对象,set函数可以接受一个数组（或者具有iterable接口的其他数据结构）作为参数

// 例一
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

// 例三
const set = new Set(document.querySelectorAll('div'));
set.size // 56

3.Set内部判断两个值是否相同于全等号===机制类似，主要的区别在于Set认为NaN等于自身；此外，两个对象总是不相等的；

4.Set的属性和方法
属性：

Set.prototype.constructor：构造函数，默认就是Set函数。
Set.prototype.size：返回Set实例的成员总数。

操作方法：

Set.prototype.add(value)：添加某个值，返回 Set 结构本身。
Set.prototype.delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
Set.prototype.has(value)：返回一个布尔值，表示该值是否为Set的成员。
Set.prototype.clear()：清除所有成员，没有返回值。

遍历方法：

Set.prototype.keys()：返回键名的遍历器
Set.prototype.values()：返回键值的遍历器
Set.prototype.entries()：返回键值对的遍历器
Set.prototype.forEach()：使用回调函数遍历每个成员
注意：set的键名和键值是同一个值，所有keys方法和values方法的行为一致

5.Array.from方法可以将Set结构转为数组

function dedupe(array) {
  return Array.from(new Set(array));
}//数组去重

dedupe([1, 1, 2, 3]) // [1, 2, 3]

6.set的应用
1）去除数组重复成员

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

2)去除字符串里面的重复字符

[...new Set('ababbc')].join('')
// "abc"

3）实现并集，交集和差集

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}

// （a 相对于 b 的）差集
let difference = new Set([...a].filter(x => !b.has(x)));
// Set {1}

Map

1.类似于对象，也是键值对的集合，各种类型的值都可以当作键
2.实例化Map对象，任何具有 Iterator 接口、且每个成员都是一个双元素的数组的数据结构都可以当作Map构造函数的参数；

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

const set = new Set([
  ['foo', 1],
  ['bar', 2]
]);
const m1 = new Map(set);
m1.get('foo') // 1

const m2 = new Map([['baz', 3]]);
const m3 = new Map(m2);
m3.get('baz') // 3

3.对一个键多次赋值，则后面的值将覆盖前面的值；如果读取一个未知的键，则返回undefined；

4.Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键

const map = new Map();
map.set(['a'], 555);
map.get(['a']) // undefined

const map = new Map();
const k1 = ['a'];
const k2 = ['a'];
map
.set(k1, 111)
.set(k2, 222);
map.get(k1) // 111
map.get(k2) // 222

5.如果 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

6.属性和方法
属性：

size:属性返回 Map 结构的成员总数。
方法：
Map.prototype.set(key, value)：设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该键。

let map = new Map()
  .set(1, 'a')
  .set(2, 'b')
  .set(3, 'c');//采用链式写法

Map.prototype.get(key):方法读取key对应的键值，如果找不到key，返回undefined。
Map.prototype.has(key):has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中。
Map.prototype.delete(key):删除某个键，返回true。如果删除失败，返回false。
Map.prototype.clear():清除所有成员，没有返回值。
Map.prototype.keys()：返回键名的遍历器。
Map.prototype.values()：返回键值的遍历器。
Map.prototype.entries()：返回所有成员的遍历器。，Map结构的默认遍历器接口
Map.prototype.forEach()：遍历 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.forEach(function(value, key, map) {
  console.log("Key: %s, Value: %s", key, value);
});

7.与其他数据结构的互相转换
1）数组

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

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

2）对象

//转为对象
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 }

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

3）JSON

//转为JSON
//1.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}'

//2.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"]]]'

//转为Map
//1.正常情况下，所有键名都是字符串。
function jsonToStrMap(jsonStr) {
  return objToStrMap(JSON.parse(jsonStr));
}

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

//2.整个 JSON 就是一个数组，且每个数组成员本身，又是一个有两个成员的数组
function jsonToMap(jsonStr) {
  return new Map(JSON.parse(jsonStr));
}

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

posted @ 2020-12-16 23:24 xiong~~ 阅读(95) 评论(0) 收藏举报

刷新页面返回顶部

Set和Map数据结构

Set

Map

公告