x-note
  • Introduction
  • JavaScript
    • JavaScript 作用域链
    • JavaScript 数据结构与类型
    • JavaScript 原型
    • JavaScript this 关键字
    • JavaScript 函数
    • JavaScript delete 运算符
    • JavaScript 内存管理与垃圾回收
    • JavaScript 严格模式与混乱模式
    • JavaScript 数字精度丢失
    • JavaScript 并发模型
    • 利用原型链实现继承
  • ECMAScript
    • ECMAScript 6 变量及常量的声明
    • ECMAScript 6 变量的解构赋值
    • ECMAScript 6 Promise 对象
    • ECMAScript 6 Symbol
    • ECMAScript 6 Proxy
    • ECMAScript 6 Reflect
    • ECMAScript 6 new.target
    • ECMAScript 6 Set 和 WeakSet
    • ECMAScript 6 Map 和 WeakMap
    • ECMAScript 6 Iterator
    • ECMAScript 6 Generator
    • ECMAScript 6 class
    • ECMAScript 7
    • ECMAScript 8 async 函数
    • ECMAScript 8 内存共享与原子性
    • ECMAScript 8 Others
    • ECMAScript 2018
    • ECMAScript 2019
  • CSS
    • CSS 块格式化上下文(BFC)
    • CSS 盒模型
    • CSS 外边距合并
    • CSS Float
    • CSS Position
    • CSS Border-Image
    • CSS BEM
    • CSS 表布局详解
    • 页面布局之单列布局
    • 页面布局之多列布局
  • React
    • React 组件的生命周期
    • React 虚拟 DOM
    • React Reconciliation
    • React Diff 算法核心
    • React Fiber
    • React Scheduling
    • React Context API
    • React Refs
    • React HMR
    • React Hook
  • VUE
    • VUE 响应式系统
    • VUE 渲染机制
    • 关于 Vue 的思考
  • Webpack
    • Webpack 基本概念
    • Webpack HMR
  • Babel
    • @babel/preset-env
  • WEB
    • WEB 基础知识及概念
      • 屏幕测量单位
      • 重绘与重排
      • 前端模块化系统
      • WEB 客户端存储
      • 浏览器的渲染过程
    • WEB 性能优化
      • WEB 性能指标
      • WEB 图片优化
      • 懒加载资源
    • WEB 安全
      • XSS
      • XSRF
      • 点击劫持
      • 同源策略(Same Origin Policy,SOP)
    • WEB 解决方案
      • webp 兼容方案
      • WEB 拖拽实现方案
    • WEB SEO
  • Git
    • Git 工作流
    • Git 内部原理
  • 传输协议
    • UDP
      • UDP 基本概念
    • TCP
      • TCP 基本概念
    • HTTP
      • HTTP 基础
      • HTTP 缓存
      • HTTP-2
      • HTTP-3
      • HTTPS
      • 自定义 HTTPS 证书
  • Protocol Buffers
    • Protocol Buffers 基础
  • gRPC
    • gRPC 简介
    • gRPC 基础概念
    • GRPC with GraphQL and TypeScript
  • 正则表达式
    • 正则表达式基础
    • 正则表达式的悲观回溯
  • 基础算法
    • 冒泡排序
    • 插入排序
    • 选择排序
    • 快速排序
    • 归并排序
    • 希尔排序
    • 堆排序
    • 桶排序
    • 计数排序
    • 基数排序
    • 二叉树的遍历
    • 动态规划
    • 回溯
  • 压缩算法
    • HPACK
    • QPACK
  • 设计模式
    • DDD
      • 模型元素的模式
    • 常见设计模式
      • 工厂方法
      • 抽象工厂
      • 构造器
      • 原型
      • 单例模式
      • 适配器模式
      • 桥接模式
      • 组合模式
      • 外观模式
      • 享元模式
      • 代理模式
      • 责任链模式
      • 命令模式
      • 迭代器模式
      • 中介者模式
      • 备忘录模式
      • 观察者模式
      • 状态模式
      • 策略模式
      • 模版方法模式
      • 访问者模式
      • 依赖注入
    • MVC
    • MVP
    • MVVM
  • 颜色空间
    • LCH
由 GitBook 提供支持
在本页
  • Map
  • 相关 API
  • WeakMap
  • 相关 API
在GitHub上编辑
  1. ECMAScript

ECMAScript 6 Map 和 WeakMap

Map和WeakMap也是 ES6 推出的新的数据结构。

Map

Map对象保存着多组键值对,与Object不同的是,任何对象或原始值都可以作为一个键。

Map对象的键是唯一的,Map比较键是否是唯一的算法是"Same-value-zero equality",与Set比较值是否唯一的算法一样,除了NaN === NaN,其他运算结构与===运算发一致。

const myMap = new Map();

const key1 = {};
const key2 = function () {};
const key3 = 'str';

myMap
.set(key1, 'key is object')
.set(key2, 'key is function')
.set(key3, 'key is str')
.set(NaN, 'key is NaN');
myMap.size; // 3


myMap.get(key1); // key is object
myMap.get(key2); // key is function
myMap.get(key3); // key is str
myMap.get(NaN); // key is NaN
myMap.get({}); // undefined

能够给Map对象的构造函数传入一个二维数组,直接生成一个Map实例

const myMap = new Map([['key', 'val']]);
myMap.get('key'); // val

Map对象也实现了 Iterator 协议,因此能够使用for...of语句遍历,使用for...of语句遍历Map对象时,返回一个[key, val]数组

var myMap = new Map();
myMap
.set(0, "zero")
.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key, value);
}
// 0 'zero'
// 1 'one'

大多数情况下,都能使用Object来替代Map对象,那么在选择使用Map对象还是Object时,可以考虑以下问题:

  • 在运行之前 key 是否是未知的?

  • 是否需要动态地查询 key 呢?

  • 是否所有的值都是统一类型,这些值可以互换么?

  • 是否需要不是字符串类型的 key ?

  • 键值对经常增加或者删除么?

  • 是否有任意个且非常容易改变的键值对?

  • 这个集合可以遍历么(Is the collection iterated)?

如果,满足上述条件中的大多数,那么使用Map会比Object更好。

相关 API

Map.prototype.set(key, val)

设置Map对象中键的值。返回该Map对象。

const myMap = new Map();

myMap
  .set('key1', 'val1')
  .set('key2', 'val2')
  .set('key3', 'val3');
myMap.size; // 3

Map.prototype.get(key)

返回键对应的值,如果不存在,则返回undefined。

const myMap = new Map([['key', 'val']]);
myMap.get('key'); // val
myMap.get('key2'); // undefined

Map.prototype.delete(key)

移除该键的关联,如果存在关联返回true,不存在则返回false。

const myMap = new Map([['key', 'val']]);
myMap.get('key'); // val
myMap.delete('key'); // true
myMap.get('key'); // undefined
myMap.delete('key'); // false

Map.prototype.has(key)

返回一个布尔值,表示Map实例是否包含键对应的值。

const myMap = new Map([['key', 'val']]);
myMap.has('key'); // true

Map.prototype.clear()

移除Map对象的所有键/值对

const myMap = new Map([['key', 'val']]);
myMap.clear();

Map.prototype.entries()

返回一个新的Iterator对象,它按插入顺序包含了Map对象中每个元素的[key, value]数组。

const myMap = new Map([['key', 'val'], ['key2', 'val2']]);
const mapIter = myMap.entries();
mapIter.next().value; // ['key', 'val']
mapIter.next().value; // ['key2', 'val2']

Map.prototype.keys()

返回一个新的Iterator对象, 它按插入顺序包含了Map对象中每个元素的键。

const myMap = new Map([['key', 'val'], ['key2', 'val2']]);
const mapIter = myMap.keys();
mapIter.next().value; // key
mapIter.next().value; // key2

Map.prototype.values()

返回一个新的Iterator对象,它按插入顺序包含了Map对象中每个元素的值。

const myMap = new Map([['key', 'val'], ['key2', 'val2']]);
const mapIter = myMap.keys();
mapIter.next().value; // val
mapIter.next().value; // val2

Map.prototype.forEach(callBack[, context])

按插入顺序,为Map对象里的每一键值对调用一次回调函数。如果为forEach提供了context,它将在每次回调中作为this值。

const myMap = new Map([['key', 'val'], ['key2', 'val2']]);
myMap.forEach(function (val, key, map) {
    console.log(key, val, this);
}, {});
// key val {}
// key2 val2 {}

WeakMap

与Map所不同的是,WeakMap中的键必须是对象,而其是弱引用的。(值可以是任意的)

在 JavaScript 里,可以通过四个共用两个数组(一个存放键,一个存放值)的 API 方法来实现 map API。给该 map 设置值时会同时将键和值推到这两个数组的末尾。从而使得键和值的索引在两个数组中相对应。当从该 map 取值的时候,需要遍历所有的键,然后使用此索引从存储值的数组中检索出相应的值。

但这样的实现会有两个很大的缺点,首先是** O(n) 的时间复杂度**(n 是键值对的个数)。另外一个则可能会导致内存泄漏,在这种自己实现的 WeakMap 中,存放键的数组中的每个索引将会保持对所引用对象的引用,阻止他们被当作垃圾回收。

而在原生的 WeakMap 中,每个键对自己所引用对象的引用是 "弱引用",这意味着,如果没有其他引用和该键引用同一个对象,这个对象将会被当作垃圾回收。原生 WeakMap 的结构是特殊且有效的,其用于映射的 key 只有在其没有被回收时才是有效的。

正由于这样的弱引用,WeakMap的 key 是非枚举的 (没有方法能给出所有的 key)。如果key 是可枚举的话,其列表将会受垃圾回收机制的影响,从而得到不确定的结果. 因此,如果你想要这种类型对象的 key 值的列表,你应该使用Map。

var wm1 = new WeakMap(),
    wm2 = new WeakMap(),
    wm3 = new WeakMap();
var o1 = {},
    o2 = function(){},
    o3 = window;

wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // value可以是任意值,包括一个对象
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // 键和值可以是任意对象,甚至另外一个WeakMap对象
wm1.get(o2); // "azerty"
wm2.get(o2); // undefined,wm2中没有o2这个键
wm2.get(o3); // undefined,值就是undefined

wm1.has(o2); // true
wm2.has(o2); // false
wm2.has(o3); // true (即使值是undefined)

wm3.set(o1, 37);
wm3.get(o1); // 37
wm3.clear();
wm3.get(o1); // undefined,wm3已被清空
wm1.has(o1);   // true
wm1.delete(o1);
wm1.has(o1);   // false

相关 API

WeakMap.prototype.set(key, val)

移除key的关联对象。

WeakMap.prototype.get(key)

返回key关联对象, 没有key关联对象时返回undefined。

WeakMap.prototype.delete(key, val)

移除该键的关联,如果存在关联返回true,不存在则返回false。

**WeakMap.prototype.has(key, val) **

返回一个布尔值,表明WeakMap实例是否包含键对应的值。

上一页ECMAScript 6 Set 和 WeakSet下一页ECMAScript 6 Iterator

最后更新于7年前