2025-01-02 日报 Day54

2025-01-02 日报 Day54

Yuyang 前端小白🥬

今日的鸡汤

好书也许不能立马带给你想要的成功,但它们一定能让你成为更好的自己。

今日学习内容

1、JS红皮书P168-172 第六章:集合引用类型

今日笔记

1、选择Object还是Map: 对于多数 Web 开发任务来说,选择 Object 还是 Map 只是个人偏好问题,影响不大。不过,对于在乎内存和性能的开发者来说,对象和映射之间确实存在显著的差别。

  • 内存占用: Object 和 Map 的工程级实现在不同浏览器间存在明显差异,但存储单个键/值对所占用的内存数量都会随键的数量线性增加。批量添加或删除键/值对则取决于各浏览器对该类型内存分配的工程实现。不同浏览器的情况不同,但给定固定大小的内存,Map 大约可以比 Object 多存储 50%的键/值对
  • 插入性能: 向 Object 和 Map 中插入新键/值对的消耗大致相当,不过插入 Map 在所有浏览器中一般会稍微快一点儿。对这两个类型来说,插入速度并不会随着键/值对数量而线性增加。如果代码涉及大量插入操作,那么显然 Map 的性能更佳。
  • 查找速度: 与插入不同,从大型 Object 和 Map 中查找键/值对的性能差异极小,但如果只包含少量键/值对,则 Object 有时候速度更快。在把 Object 当成数组使用的情况下(比如使用连续整数作为属性),浏览器引擎可以进行优化,在内存中使用更高效的布局。这对 Map 来说是不可能的。对这两个类型而言,查找速度不会随着键/值对数量增加而线性增加。如果代码涉及大量查找操作,那么某些情况下可能选择 Object 更好一些。
  • 删除性能: 使用 delete 删除 Object 属性的性能一直以来饱受诟病,目前在很多浏览器中仍然如此。为此,出现了一些伪删除对象属性的操作,包括把属性值设置为 undefined 或 null。但很多时候,这都是一种讨厌的或不适宜的折中。而对大多数浏览器引擎来说,Map 的 delete()操作都比插入和查找更快。如果代码涉及大量删除操作,那么毫无疑问应该选择 Map。
    2、WeakMap: ECMAScript 6 新增的“弱映射”(WeakMap)是一种新的集合类型,为这门语言带来了增强的键/值对存储机制。WeakMap 是 Map 的“兄弟”类型,其 API 也是 Map 的子集。WeakMap 中的“weak”(弱),描述的是 JavaScript 垃圾回收程序对待“弱映射”中键的方式。
    基本API:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    // 使用 new 关键字和 WeakMap 构造函数可以创建一个空弱映射:
    const wm = new WeakMap();
    // 弱映射中的键只能是 Object 或者继承自 Object 的类型,尝试使用非对象设置键会抛出TypeError。值的类型没有限制。
    // 如果想在初始化时填充弱映射,则构造函数可以接收一个可迭代对象,其中需要包含键/值对数组。可迭代对象中的每个键/值都会按照迭代顺序插入新实例中:
    const key1 = {id: 1},
    key2 = {id: 2},
    key3 = {id: 3};
    // 使用嵌套数组初始化弱映射
    const wm1 = new WeakMap([
    [key1, "val1"],
    [key2, "val2"],
    [key3, "val3"]
    ]);
    alert(wm1.get(key1)); // val1
    alert(wm1.get(key2)); // val2
    alert(wm1.get(key3)); // val3

    // 初始化是全有或全无的操作
    // 只要有一个键无效就会抛出错误,导致整个初始化失败
    const wm2 = new WeakMap([
    [key1, "val1"],
    ["BADKEY", "val2"],
    [key3, "val3"]
    ]);
    // TypeError: Invalid value used as WeakMap key
    typeof wm2;
    // ReferenceError: wm2 is not defined
    // 原始值可以先包装成对象再用作键
    const stringKey = new String("key1");
    const wm3 = new WeakMap([
    stringKey, "val1"
    ]);
    alert(wm3.get(stringKey)); // "val1"
    初始化之后可以使用 set()再添加键/值对,可以使用 get()和 has()查询,还可以使用 delete()删除:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    const wm = new WeakMap(); 
    const key1 = {id: 1},
    key2 = {id: 2};
    alert(wm.has(key1)); // false
    alert(wm.get(key1)); // undefined
    wm.set(key1, "Matt")
    .set(key2, "Frisbie");
    alert(wm.has(key1)); // true
    alert(wm.get(key1)); // Matt
    wm.delete(key1); // 只删除这一个键/值对
    alert(wm.has(key1)); // false
    alert(wm.has(key2)); // true
    set()方法返回弱映射实例,因此可以把多个操作连缀起来,包括初始化声明:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    const key1 = {id: 1}, 
    key2 = {id: 2},
    key3 = {id: 3};
    const wm = new WeakMap().set(key1, "val1");
    wm.set(key2, "val2")
    .set(key3, "val3");
    alert(wm.get(key1)); // val1
    alert(wm.get(key2)); // val2
    alert(wm.get(key3)); // val3
    3、弱键: WeakMap 中“weak”表示弱映射的键是“弱弱地拿着”的。意思就是,这些键不属于正式的引用,不会阻止垃圾回收。但要注意的是,弱映射中值的引用可不是“弱弱地拿着”的。只要键存在,键/值对就会存在于映射中,并被当作对值的引用,因此就不会被当作垃圾回收。
    来看下面的例子:
    1
    2
    const wm = new WeakMap(); 
    wm.set({}, "val");
    set()方法初始化了一个新对象并将它用作一个字符串的键。因为没有指向这个对象的其他引用,所以当这行代码执行完成后,这个对象键就会被当作垃圾回收。然后,这个键/值对就从弱映射中消失了,使其成为一个空映射。在这个例子中,因为值也没有被引用,所以这对键/值被破坏以后,值本身也会成为垃圾回收的目标。
    再看一个稍微不同的例子:
    1
    2
    3
    4
    5
    6
    7
    8
    const wm = new WeakMap(); 
    const container = {
    key: {}
    };
    wm.set(container.key, "val");
    function removeReference() {
    container.key = null;
    }
    这一次,container 对象维护着一个对弱映射键的引用,因此这个对象键不会成为垃圾回收的目标。不过,如果调用了 removeReference(),就会摧毁键对象的最后一个引用,垃圾回收程序就可以把这个键/值对清理掉。
    不可迭代键: 因为 WeakMap 中的键/值对任何时候都可能被销毁,所以没必要提供迭代其键/值对的能力。当然,也用不着像 clear()这样一次性销毁所有键/值的方法。WeakMap 确实没有这个方法。因为不可能迭代,所以也不可能在不知道对象引用的情况下从弱映射中取得值。即便代码可以访问 WeakMap 实例,也没办法看到其中的内容。
    WeakMap 实例之所以限制只能用对象作为键,是为了保证只有通过键对象的引用才能取得值。如果允许原始值,那就没办法区分初始化时使用的字符串字面量和初始化之后使用的一个相等的字符串了
    4、弱映射的应用:
  • 私有变量: 弱映射造就了在 JavaScript 中实现真正私有变量的一种新方式。前提很明确:私有变量会存储在弱映射中,以对象实例为键,以私有成员的字典为值。下面是一个示例实现:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    const wm = new WeakMap(); 
    class User {
    constructor(id) {
    this.idProperty = Symbol('id');
    this.setId(id);
    }
    setPrivate(property, value) {
    const privateMembers = wm.get(this) || {};
    privateMembers[property] = value;
    wm.set(this, privateMembers);
    }
    getPrivate(property) {
    return wm.get(this)[property];
    }
    setId(id) {
    this.setPrivate(this.idProperty, id);
    }
    getId() {
    return this.getPrivate(this.idProperty);
    }
    }
    const user = new User(123);
    alert(user.getId()); // 123
    user.setId(456);
    alert(user.getId()); // 456
    // 并不是真正私有的
    alert(wm.get(user)[user.idProperty]); // 456
    慧眼独具的读者会发现,对于上面的实现,外部代码只需要拿到对象实例的引用和弱映射,就可以取得“私有”变量了。为了避免这种访问,可以用一个闭包把 WeakMap 包装起来,这样就可以把弱映射与外界完全隔离开了:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    const User = (() => { 
    const wm = new WeakMap();
    class User {
    constructor(id) {
    this.idProperty = Symbol('id');
    this.setId(id);
    }

    setPrivate(property, value) {
    const privateMembers = wm.get(this) || {};
    privateMembers[property] = value;
    wm.set(this, privateMembers);
    }

    getPrivate(property) {
    return wm.get(this)[property];
    }

    setId(id) {
    this.setPrivate(this.idProperty, id);
    }

    getId() {
    return this.getPrivate(this.idProperty);
    }
    }
    return User;
    })();
    const user = new User(123);
    alert(user.getId()); // 123
    user.setId(456);
    alert(user.getId()); // 456
    这样,拿不到弱映射中的健,也就无法取得弱映射中对应的值。虽然这防止了前面提到的访问,但整个代码也完全陷入了 ES6 之前的闭包私有变量模式。
  • DOM节点元数据: 因为 WeakMap 实例不会妨碍垃圾回收,所以非常适合保存关联元数据。来看下面这个例子,其中使用了常规的 Map:
    1
    2
    3
    const m = new Map();
    const loginButton = document.querySelector('#login');
    m.set(loginButton, {disabled: true});
    假设在上面的代码执行后,页面被 JavaScript 改变了,原来的登录按钮从 DOM 树中被删掉了。但由于映射中还保存着按钮的引用,所以对应的 DOM 节点仍然会逗留在内存中,除非明确将其从映射中删除或者等到映射本身被销毁。
    如果这里使用的是弱映射,如以下代码所示,那么当节点从 DOM 树中被删除后,垃圾回收程序就可以立即释放其内存(假设没有其他地方引用这个对象):
    1
    2
    3
    4
    const wm = new WeakMap(); 
    const loginButton = document.querySelector('#login');
    // 给这个节点关联一些元数据
    wm.set(loginButton, {disabled: true});
此页目录
2025-01-02 日报 Day54