如何正确序列化Javascript curried arrow函数？

Question

const makeIncrementer = s=>a=>a+s
makeIncrementer(10).toString()    // Prints 'a=>a+s'

这将使得无法正确反序列化（我会期待类似a=>a+10东西。有没有办法做正确的？

Answer 1

这是一个很好的问题。 虽然我没有完美的答案，但您可以通过一种方式获得有关参数的详细信息，即创建一个构建函数，为您存储必要的详细信息。 不幸的是，我无法找到一种方法来了解哪些内部变量与哪些值相关。 如果我弄明白我还会更新其他内容：

 const makeIncrementer = s => a => a + s const builder = (fn, ...args) => { return { args, curry: fn(...args) } } var inc = builder(makeIncrementer, 10) console.log(inc) // logs args and function details console.log(inc.curry(5)) // 15 

---

更新：这将是一个庞大的任务，但我意识到，如果你扩展上面的构建器的想法，你可以编写/使用一个函数字符串解析器，可以采取给定的args和外部函数，并重写日志到序列化版本。 我在下面有一个演示， 但它不适用于实际用例！ 。 我已经完成了一个简单的字符串查找/替换，而您需要使用实际的函数解析器来正确替换。 这只是你如何做到这一点的一个例子。 请注意，我还使用了两个增量变量来展示如何进行倍数。

 function replaceAll(str, find, replace) { return str.replace(new RegExp(find, 'g'), replace) } const makeIncrementer = (a, b) => c => c + a + b const builder = (fn, ...args) => { // get the outer function argument list var outers = fn.toString().split('=>')[0] // remove potential brackets and spaces outers = outers.replace(/\\(|\\)/g,'').split(',').map(i => i.trim()) // relate the args to the values var relations = outers.map((name, i) => ({ name, value: args[i] })) // create the curry var curry = fn(...args) // attempt to replace the string rep variables with their true values // NOTE: **this is a simplistic example and will break easily** var serialised = curry.toString() relations.forEach(r => serialised = replaceAll(serialised, r.name, r.value)) return { relations, serialised, curry: fn(...args) } } var inc = builder(makeIncrementer, 10, 5) console.log(inc) // shows args, serialised function, and curry console.log(inc.curry(4)) // 19 

Answer 2

您不应该序列化/解析函数体，因为这很快就会导致安全漏洞。 序列化闭包意味着序列化其本地状态，即必须使闭包的自由变量对于周围的作用域可见：

 const RetrieveArgs = Symbol(); const metaApply = f => x => { const r = f(x); if (typeof r === "function") { if (f[RetrieveArgs]) r[RetrieveArgs] = Object.assign({}, f[RetrieveArgs], {x}); else r[RetrieveArgs] = {x}; } return r; } const add = m => n => m + n, f = metaApply(add) (10); console.log( JSON.stringify(f[RetrieveArgs]) // {"x":10} ); const map = f => xs => xs.map(f) g = metaApply(map) (n => n + 1); console.log( JSON.stringify(g[RetrieveArgs]) // doesn't work with higher order functions ); 

我使用Symbol来使新属性不会干扰程序的其他部分。

如代码中所述，您仍然无法序列化高阶函数。

Answer 3

到目前为止，结合两个答案的想法，我设法生产一些有用的东西（虽然我还没有彻底测试过）：

const removeParentheses = s => {
    let match = /^\((.*)\)$/.exec(s.trim());
    return match ? match[1] : s;
}

function serializable(fn, boundArgs = {}) {
    if (typeof fn !== 'function') return fn;
    if (fn.toJSON !== undefined) return fn;

    const definition = fn.toString();
    const argNames = removeParentheses(definition.split('=>', 1)[0]).split(',').map(s => s.trim());

    let wrapper = (...args) => {
        const r = fn(...args);

        if (typeof r === "function") {
            let boundArgsFor_r = Object.assign({}, boundArgs);
            argNames.forEach((name, i) => {
                boundArgsFor_r[name] = serializable(args[i]);
            });
            return serializable(r, boundArgsFor_r);
        }
        return r;
    }

    wrapper.toJSON = function () {
        return { function: { body: definition, bound: boundArgs } };
    }
    return wrapper;
}

const add = m => m1 => n => m + n * m1,
    fn = serializable(add)(10)(20);

let ser1, ser2;

console.log(
    ser1 = JSON.stringify(fn)          // {"function":{"body":"n => m + n * m1","bound":{"m":10,"m1":20}}}
);

const map = fn => xs => xs.map(fn),
    g = serializable(map)(n => n + 1);

console.log(
    ser2 = JSON.stringify(g)   // {"function":{"body":"xs => xs.map(fn)","bound":{"fn":{"function":{"body":"n => n + 1","bound":{}}}}}}
);

const reviver = (key, value) => {
    if (typeof value === 'object' && 'function' in value) {
        const f = value.function;
        return eval(`({${Object.keys(f.bound).join(',')}}) => (${f.body})`)(f.bound);
    }
    return value;
}

const rev1 = JSON.parse(ser1, reviver);
console.log(rev1(5));   // 110

const rev2 = JSON.parse(ser2, reviver);
console.log(rev2([1, 2, 3]));   // [2, 3, 4]

这适用于箭头函数，它没有参数的默认初始值设定项。 它也支持更高阶的功能。 在将原始函数应用于任何参数之前，仍然必须能够将原始函数包装成可serializable 。 感谢@MattWay和@ftor的宝贵意见！