Vue进阶（贰零贰）：集合 Set 和 Map

转x33g5p2x  于2021-11-11 转载在 Vue.js  
字(5.8k)|赞(0)|评价(0)|浏览(412)

一、集合的概念

集合是由一组无序且唯一（元素不能重复）的项组成的。这个数据结构使用了与有限集合相同的数学概念，应用在计算机的数据结构中特点：key和value相同，没有重复的value.

二、Set集合

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

Set数据结构的创建——Set方法里可以指定参数，也可以不指定参数（参数是一个数组）。

  1. const s1 = new Set();
  2. const s2 = new Set([1,2,3,4]);
  4. console.log(s1) // Set {}
  5. console.log(s2) // Set { 1, 2, 3, 4 }

Set类的属性——获取Set类中有几个数据。

  1. const s1 = new Set();
  2. const s2 = new Set([1,2,3,4]);
  4. console.log(s1.size) // 0
  5. console.log(s2.size) // 4

Set类的方法—Set.add(value)——Set.add(value) 添加一个数据，返回Set结构本身

成员的值都是唯一的，没有重复的值，所以在后面添加相同的值到set结构中是无效的

  1. s1.add('a').add('b');
  2. console.log(s1)   //Set { 'a', 'b' }
  4. s2.add('c')
  5. console.log(s2);   //Set { 1, 2, 3, 4, 'c' }
  7. s2.add(1);
  8. console.log(s2);  //已经有相同的值了，所以添加无效还是原来的 Set { 1, 2, 3, 4, 'c' }

Set类的方法—Set.delete(value) set.delete(value) 删除指定数据，返回一个布尔值，表示删除是否成功

  1. const s2 = new Set([1,2,3,4]);
  3. var ba1 = s2.delete(1)
  4. var ba2 = s2.delete('c')
  6. console.log(ba1); //true
  7. console.log(ba2); //false
  8. console.log(s2); //Set { 2, 3, 4 }

Set类的方法—Set.has(value)——判断该值是否为set的成员，返回一个布尔值

  1. const s = new Set([1,2,3,4]);
  3. const bs1 = s.has(1);
  4. const bs2 = s.has('a');
  5. console.log(bs1,bs2);   //true false

Set类的方法—Set.clear()——清除所有的数据，没有返回值

  1. const s = new Set([1,2,3,4]);
  3. s.clear();
  4. console.log(s);  // Set {}

Set的遍历器——keys() 返回键名的遍历器，values() 返回键值的遍历器，entries() 返回键值对的遍历器，forEach() 使用回调函数遍历每个成员

  1. const s = new Set([1,2,3,4]);
  3. console.log(s.keys());  // SetIterator { 1, 2, 3, 4 }
  4. console.log(s.values());   //SetIterator { 1, 2, 3, 4 }
  5. console.log(s.entries());   //SetIterator { [ 1, 1 ], [ 2, 2 ], [ 3, 3 ], [ 4, 4 ] }
  7. //该方法可以接收三个参数，分别是：键值，健名，set本身
  8. s.forEach(function(value,key,set){
  9.     console.log(value+'lina');
  10.     console.log(set)
  11. })

利用Set为数组去重——直接将要给数组放入到，set的构造方法中即可

  1. const arr = [1,2,3,45,2,3,4,13,5,7,1,3,2]
  3. const s = new Set(arr);
  5. console.log(s);  // Set { 1, 2, 3, 45, 4, 13, 5, 7 }
  6. console.log(arr);   //[ 1, 2, 3, 45, 2, 3, 4, 13, 5, 7, 1, 3, 2 ]
  8. console.log([...s]);//将set转成数组，结果是[ 1, 2, 3, 45, 4, 13, 5, 7 ]

三、Map数据结构

Map数据结构概述 字典：是用来存储不重复key的Hash结构，不同于集合（Set）的是，字典使用的是[键,值]的形式来存储数据的

JavaScript 的对象（Object），本质上是键值对的集合（Hash 结构），但是传统上只能用字符串当作键。这给它的使用带来了很大的限制。

为了解决这个问题，ES6 提供了 Map 数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object 结构提供了“字符串—值”的对应，Map结构提供了“值—值”的对应，是一种更完善的 Hash 结构实现。如果你需要“键值对”的数据结构，Map 比 Object 更合适。

创建Map和Map类的属性——获取Map类中有几个数据

  1. const  m = new Map([
  2.     ['a',1],
  3.     ['b',2]
  4. ]);
  6. console.log(m);  //Map { 'a' => 1, 'b' => 2 }
  7. console.log(m.size);  //2

Map类的方法—set(key,value) 设置键名key对应的键值为value，然后返回整个Map结构，如果key已经有值，则键值会被更新，否则就生成该键

Map类的方法—get(key)——get方法读取key对应的键值，如果找不到key，返回undefined

  1. const  m = new Map([
  2.     ['a',1],
  3.     ['b',2]
  4. ]);
  6. m.set('miaov','ketang').set('xing','huang');//因为返回的是Map结构本身，所以可以使用调用链的方式
  7. console.log(m);//Map { 'a' => 1, 'b' => 2, 'miaov' => 'ketang', 'xing' => 'huang' }
  9. m.set('b',5);//有相同的key，值会被覆盖
  10. console.log(m); //Map { 'a' => 1, 'b' => 5, 'miaov' => 'ketang', 'xing' => 'huang' }
  12. console.log(m.get('b'));  //5
  13. console.log(m.get('c'));  //undefined

Map类的方法—delete(key) 删除某个键，删除成功放回true，如果删除失败，返回false

  1. const  m = new Map([
  2.     ['a',1],
  3.     ['b',2]
  4. ]);
  6. console.log(m.delete('b'));//true
  7. console.log(m.delete('c'));//false
  8. console.log(m);//Map { 'a' => 1 }

Map类的方法—has(key) 方法返回一个布尔值，表示某个键是否在当前Map对象之中

Map类的方法—clear() 清楚Map结构中的所有数据，没有返回值

  1. const  m = new Map([
  2.     ['a',1],
  3.     ['b',2]
  4. ]);
  6. console.log(m.has('b'));//true
  7. console.log(m.has('c'));//false
  9. m.clear();
  10. console.log(m);//Map {}

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

  1. const  m = new Map([
  2.     ['a',1],
  3.     ['b',2],
  4.     ['c',3]
  5. ]);
  7. console.log(m.keys());//MapIterator { 'a', 'b', 'c' }
  8. console.log(m.values()); //MapIterator { 1, 2, 3 }
  9. console.log(m.entries());  //MapIterator { [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ] }
  11. //该方法可以接收三个参数：值，键，Map本身
  12. m.forEach(function (value, key, Map) {
  13.     console.log(value);
  14.     console.log(key);
  15. })

Map在使用过程中的一些注意事项一两个NaN本身是不相等的，但在Map结构中，NaN作为键的话，视为相等的（同一个键）

  1. const  map = new Map();
  2. map.set(NaN,1);
  3. map.set(NaN,2);
  5. console.log(map); //Map { NaN => 2 }

Map在使用过程中的一些注意事项二 如果Map结构中的key是一个对象的情况下，每个对象都是不同的键，即使是两个空的对象，因为两个对象的地址值不同，以后引用别人的插件，使用对象作为键，就能避免同名碰撞的情况

  1. const map = new Map();
  3. map.set({},'x').set({},'y');
  5. console.log(map); //Map { {} => 'x', {} => 'y' }

Map 结构转为数组结构——比较快速的方法是使用扩展运算符（…）。

  1. const  m = new Map([
  2.     ['a',1],
  3.     ['b',2]
  4. ]);
  6. console.log([...m.keys()]);  //[ 'a', 'b' ]
  7. console.log([...m.values()]);  //[ 1, 2 ]
  8. console.log([...m.entries()]);   //[ [ 'a', 1 ], [ 'b', 2 ] ]
  9. console.log([...m]);   //[ [ 'a', 1 ], [ 'b', 2 ] ]

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

  1. const arr = [[1,'one'],[2,'two'],[3,'three']];
  3. const map = new Map(arr);
  5. console.log(map);//Map { 1 => 'one', 2 => 'two', 3 => 'three' }

Map结构转为对象——如果所有 Map 的键都是字符串，它可以转为对象

  1. const myMap = new Map();
  3. myMap.set('yes', true)
  4. myMap .set('no', false);
  5. console.log(myMap);   //Map { 'yes' => true, 'no' => false }
  7. const obj = strMapToObj(myMap);
  8. console.log(obj); //{ yes: true, no: false }
  10. function strMapToObj(strMap) {
  11.     let obj = Object.create(null);
  12.     for (let [k,v] of strMap) {
  13.         obj[k] = v;
  14.     }
  15.     return obj;
  16. }

对象转为Map结构

  1. function objToStrMap(obj) {
  2.     let strMap = new Map();
  3.     for (let k of Object.keys(obj)) {
  4.         strMap.set(k, obj[k]);
  5.     }
  6.     return strMap;
  7. }
  9. const map = objToStrMap({yes: true, no: false});
  10. console.log(map);  //Map { 'yes' => true, 'no' => false }

Map结构转为JSON对象 Map 转为 JSON 要区分两种情况。一种情况是，Map 的键名都是字符串，这时可以选择转为对象 JSON。 需要先将其转成对象

  1. function strMapToJson(strMap) {
  2.     return JSON.stringify(strMapToObj(strMap));
  3. }
  5. function strMapToObj(strMap) {
  6.     let obj = Object.create(null);
  7.     for (let [k,v] of strMap) {
  8.         obj[k] = v;
  9.     }
  10.     return obj;
  11. }
  13. let myMap = new Map().set('yes', true).set('no', false);
  14. console.log(strMapToJson(myMap));  //{"yes":true,"no":false}

另一种情况是，Map 的键名有非字符串，这时可以选择转为数组 JSON

  1. function mapToArrayJson(map) {
  2.     return JSON.stringify([...map]);
  3. }
  5. let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
  6. console.log(mapToArrayJson(myMap));  //[[true,7],[{"foo":3},["abc"]]]
  7. JSON转为Map结构——JSON 转为 Map，正常情况下，所有键名都是字符串
  9. function jsonToStrMap(jsonStr) {
  10.     return objToStrMap(JSON.parse(jsonStr));
  11. }
  13. function objToStrMap(obj) {
  14.     let strMap = new Map();
  15.     for (let k of Object.keys(obj)) {
  16.         strMap.set(k, obj[k]);
  17.     }
  18.     return strMap;
  19. }
  21. console.log(jsonToStrMap('{"yes": true, "no": false}'));  //Map { 'yes' => true, 'no' => false }

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

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

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/sunhuaqiang1/article/details/115405460

内容来源于网络，如有侵权，请联系作者删除！

vue.jsJavaScript前端开卷有益

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com