es6 map成员是不是唯一的

今天小编给大家分享一下es6 map成员是不是唯一的的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。

es6 map成员是唯一的。ES6新增的Map数据结构类似于对象，key值不限于字符串，成员值唯一；Map结构提供了“值—值”的对应，是一种更完善的Hash结构实现。Map对象保存键值对，并且能够记住键的原始插入顺序；任何值（对象或者原始值）都可以作为一个键或一个值。

Map和Set都是ES6新增的数据结构

• Map 类似于对象，key值不限于字符串，成员值唯一。

• Set 类似于数组，成员值唯一。

Map 基本概念

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

Map 特征

• Map 对象保存键值对，并且能够记住键的原始插入顺序。

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

• Map 是 ES6 中引入的一种新的数据结构，可以参考 ES6 Map 与 Set。

Maps 和 Objects 的区别

• 一个 Object 的键只能是字符串或者 Symbols，但一个 Map 的键可以是任意值。

• Map 中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。

  关于对象是无序的官方解释：1.An object is a member of the type Object. It is an unordered collection of properties each of which contains a primitive value,object, or function. A function stored in a property of an object iscalled a method.2.Chrome Opera 的 JavaScript 解析引擎遵循的是新版 ECMA-262 第五版规范。因此，使用 for-in 语句遍历对象属性时遍历书序并非属性构建顺序。而 IE6 IE7 IE8 Firefox Safari 的 JavaScript解析引擎遵循的是较老的 ECMA-262 第三版规范，属性遍历顺序由属性构建的顺序决定。

• Map 的键值对个数可以从 size 属性获取，而 Object 的键值对个数只能手动计算。

• Object 都有自己的原型，原型链上的键名有可能和你自己在对象上的设置的键名产生冲突。

Map 属性

• Map.prototype.size – 返回 Map 对象键/值对的数量。

Map 操作方法

• Map.prototype.clear() – 移除 Map 对象的所有键/值对 。

• Map.prototype.set() – 设置键值对，返回该 Map 对象。

• Map.prototype.get() – 返回键对应的值，如果不存在，则返回 undefined。

• Map.prototype.has() – 返回一个布尔值，用于判断 Map 中是否包含键对应的值。

• Map.prototype.delete() – 删除 Map 中的元素，删除成功返回 true，失败返回 false。

Map 循环方法

Map 的遍历顺序就是插入顺序。

• Map.prototype.keys()：返回键名的遍历器。

• Map.prototype.values()：返回键值的遍历器。

• Map.prototype.entries()：返回所有成员的遍历器。

• Map.prototype.forEach()：遍历 Map 的所有成员。

其他方法

• for of 由于有iterable 所以也可以使用此方法

开始创建

使用 Map 类型和 new 关键字来创建 Map：

不仅仅是数组，任何具有 Iterator 接口、且每个成员都是一个双元素的数组的数据结构所以 Set Map 数组 都可以创建 Map

创建空map 再添加

let map1 = new Map();map1.set('123',123)

数组创建Map

const m2 = new Map([['baz', 3]]);

set 创建Map

const set = new Set([  ['foo', 1],  ['bar', 2]]);const m3 = new Map(set);

map 创建新的map

注意 m3 === m2 //false

const m3 = new Map(m2);

例子：可以做什么

和对象最大的区别： 多类型的key

字符串

var myMap = new Map(); var keyString = "a string"; myMap.set(keyString, "和键'a string'关联的值");

对象

var myMap = new Map(); var keyObj = {}myMap.set(keyObj, "和键 keyObj 关联的值");

函数

var myMap = new Map(); var keyFunc = function () {} // 函数 myMap.set(keyFunc, "和键 keyFunc 关联的值");

NaN

var myMap = new Map(); myMap.set(NaN, "not a number");

Map 遍历成员方法

keys() ， values() ， entries()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);}

使用扩展运算符可以快速转数组

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方法

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 增 删 查 清空

const m = new Map();const o = {p: 'Hello World'};m.set(o, 'content')m.get(o) // "content"m.has(o) // truem.delete(o) // truem.has(o) // falsem.clear()

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

（1）Map 转为数组

前面已经提过，Map 转为数组最方便的方法，就是使用扩展运算符（...）。

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

（2）数组 转为 Map

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

new Map([  [true, 7],  [{foo: 3}, ['abc']]])// Map {//   true => 7,//   Object {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']}

其他

Map 的合并

var first = new Map([[1, 'one'], [2, 'two'], [3, 'three'],]); var second = new Map([[1, 'uno'], [2, 'dos']]); // 合并两个 Map 对象时，如果有重复的键值，则后面的会覆盖前面的，对应值即 uno，dos， three var merged = new Map([...first, ...second]);

Map 的克隆

var myMap1 = new Map([["key1", "value1"], ["key2", "value2"]]); var myMap2 = new Map(myMap1); console.log(original === clone); // 打印 false。 Map 对象构造函数生成实例，迭代出新的对象。

注意事项

注意，只有对同一个对象的引用，Map 结构才将其视为同一个键。这一点要非常小心。

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

虽然NaN不严格相等于自身，但 Map 将其视为同一个键。

let map = new Map();map.set(NaN, 123);map.get(NaN) // 123

以上就是“es6 map成员是不是唯一的”这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注编程网行业资讯频道。