如何用额外的函数调用参数替换闭包变量以避免不断地重新创建函数？

Question

给定：

list = [ "one", "something", "other" ];
foo = function () {
    var str = "something", 
        bar = function (el, idx, array) {return el === str;};
    return list.some(bar);
}; 
for (var i = 0; i < 10; i += 1) {
   foo(); // true
}

bar 由 list.some() 调用，带有三个参数。

如果我想在 foo 之外定义 bar ，那么我必须在这样的闭包中给它 str ：

list = [ "one", "something", "other" ];
bar = function (str) {
    return function baz(el, idx, array) {return el === str;};
}
foo = function () {
    var str = "something"; 
    return list.some(bar(str));
}; 
for (var i = 0; i < 10; i += 1) {
   foo(); // true
}

因此，每次调用 bar 时，都会在 bar 中创建/定义一个函数 baz。是否可以通过添加额外的来避免闭包和常量函数的重新创建
bar 的 list.some() 调用的参数如下：

list = [ "one", "something", "other" ];
bar = function (el, idx, array, str) {return el === str;};
// Do something to bar's argument list so it's called with more than three arguments?
baz = function (str) {return bar(el, idx, array, str);}; // ????
foo = function () {
    var str = "something";
    return list.some(baz(str));
};
for (var i = 0; i < 10; i += 1) {
   foo(); // true
}

更新：请注意，可以从循环中调用 foo，如上述示例中所示。 是否可以避免重新创建所有函数，使每个函数只创建一次？

我想传递 bar 四个参数（或前三个参数之后的任意数量的参数，比如这个 bar = function (el, idx, array, str, ...)。目标是只创建任何一个函数一次。请不要使用外部库。

Answer 1

使用 Function.bind 可以将上下文 this 设置为字符串。但是，function.bind 仍然会创建一个新函数。真的，没有函数就没有办法创建闭包。它们相互依赖。

我认为这是最干净的方法：

list = [ "one", "something", "other" ];
bar = function indexAndStringMatch(key) {
    return function (el, idx, array) { return el === key && idx; };
}
foo = (function () {
    var str = "something", 
        foundIt = array.some(bar(str));
}());

Answer 2

可能是：

var list = [ "one", "something", "other" ];
var bar = function (el, idx, array) { return el === this.str; };
var foo = (function () {
    var str = "something"; 
    return list.some(bar.bind({str}));
}()); 
console.log(foo)

但我不知道我是否真的了解你。

Answer 3

因此，您可以使用称为Currying (Helpful article) 的函数式编程方法来完成此操作。我认为您可以从技术上说 ramda 在幕后创建另一个函数，这是真的，但是，它定义并返回函数 1 次，而不是每次迭代，我相信这是您的目标。

代码如下所示：

var ramda = R; // alias ramda library from default R for clarity
list = [ "one", "something", "other" ];
var bar = ramda.curry(function (str, el, idx, array) {
    return el === str;
});
var foo = (function (array) {
    var str = "something", 
    // bar(str) creates a function one time that is passed to .some(),
    // rather than for each iteration
    foundIt = array.some(bar(str)); 
    return foundIt;
}(list));

console.log(foo);

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.23.0/ramda.js"></script>

请记住，没有必要专门使用 ramda 库，因为您可以使用 vanilla JS 或其他常用库（如 lodash）自己实现柯里化。

根据请求 - 自己在 JS 中 curry 一个函数，它看起来像下面这样：(Copied from this article)

function curry(fx) {
  var arity = fx.length;

  return function f1() {
    var args = Array.prototype.slice.call(arguments, 0);
    if (args.length >= arity) {
      return fx.apply(null, args);
    }
    else {
      return function f2() {
        var args2 = Array.prototype.slice.call(arguments, 0);
        return f1.apply(null, args.concat(args2)); 
      }
    }
  };
}