Javascript:重用有界函数

Question

标准 Function.prototype.bind 方法在每次调用时创建一个新函数。我需要存储在某处并重用该函数的有界变体。

实现适用于对象参数的函数bindArg并不是火箭科学:

const fnStorage = new WeakMap();
function bindArg(fn, arg) {
  if (!fnStorage.has(fn)) {
    fnStorage.set(fn, new WeakMap());
  }
  if (!fnStorage.get(fn).has(arg)) {
    fnStorage.get(fn).set(arg, fn.bind(null, arg));
  }
  return fnStorage.get(fn).get(arg);
}

此解决方案工作正常，但仅适用于对象参数。对于标量参数，可以通过将 WeakMap 更改为 Map 来完成。但这一点也不好，因为 Map 将保留对函数的有界变体的引用并防止对其进行垃圾回收。

有什么方法可以实现 bindArg 函数，该函数对于任何类型的参数都是不可变的，不会发生内存泄漏？

Answer 1

您可以对原始数据类型使用 Map，对对象使用 WeakMap:

function isPrimitive(value) {
    return Object(value) !== value;
}

var primStore = new Map;
var objStore = new WeakMap;

function bindArg(fn, arg) {
    var store = isPrimitive(arg) ? primStore : objStore;
    if (!store.has(arg)) store.set(arg, new WeakMap);
    if (!store.get(arg).has(fn)) store.get(arg).set(fn, fn.bind(null, arg));
    return store.get(arg).get(fn);
}

请注意，我们返回 store.get(arg).get(fn) 而不是 store.get(fn).get(arg)。这种翻转对 bindArg 函数的实际语义没有任何影响，但当我们想要区分原始数据类型和对象时，这是必要的。

---

编辑:或者，您可以创建一个新的 WeakMap2 数据结构，它在 Map 中存储原始值，在 中存储对象WeakMap如下:

var WeakMap2 = defclass({
    constructor: function () {
        this.map1 = new Map;
        this.map2 = new WeakMap;

        if (arguments.length > 0) {
            for (var object in argument[0]) {
                if (isPrimitive(object))
                    throw new TypeError("Iterator value " +
                        object + " is not an entry object");
                else this.set(object[0], object[1]);
            }
        }
    },
    get: function (key) {
        return (isPrimitive(key) ? this.map1 : this.map2).get(key);
    },
    set: function (key, value) {
        return (isPrimitive(key) ? this.map1 : this.map2).set(key, value);
    },
    has: function (key) {
        return (isPrimitive(key) ? this.map1 : this.map2).has(key);
    },
    delete: function (key) {
        return (isPrimitive(key) ? this.map1 : this.map2).delete(key);
    }
});

function defclass(prototype) {
    var constructor = prototype.constructor;
    constructor.prototype = prototype;
    return constructor;
}

function isPrimitive(value) {
    return Object(value) !== value;
}

但是，我不推荐它，因为它增加了一个抽象层，使您的代码变慢。