Vanilla Javascript 算法，怎么做和解释

Question

对于我的学校作业，我必须编写一个纯 Javascript 函数，称为：

foo(c)

应该返回以下值：

foo('a')  // return 'fa'
foo()('b')  // return 'fob'
foo()()("t"))  // return 'foot'

所以基本上当以字符'c'作为参数调用函数时，返回整个值（注意调用 foo() 在整体返回值中添加一个'o'字符，最终字符串返回的第一个字符是总是'f'。

有人可以提供可能的实现吗？ 理想情况下，我想自己尝试，因此也非常欢迎提示和提示，以及代码中的注释。

注意：我目前最大的困难是找到一种链接调用函数的方法。

谢谢你。

Answer 1

这是一种带有箭头函数的递归方法：

const foo = c => {
    let rec = acc => x => x === undefined ? rec(acc + "o") : foo(acc + x);
    return c === undefined ? rec("o") : "f" + c;
};

foo('t'); // "ft"
foo()('t'); // "fot"
foo()()('t'); // "foot"

foo是一个一元函数，但可以处理这种情况，当它被调用时没有任何参数。 内部函数rec以柯里化形式定义，并接受一个累加器作为它的第一个参数和一个字符串作为它的第二个参数。 每当省略第二个参数时， rec递归地调用自身。

Answer 2

Iven 的回答激励我接受这个有趣的挑战

// ES6
const foo = (x,y='f') => x && (y + x) || (x => foo(x, y + 'o'));
foo('a'); // "fa"
foo()('b'); // "fb"
foo()()('t'); // "foot"

---

对于仍在使用 ES5 的人...

// ES5
var foo = function foo(x) {
  var y = arguments.length <= 1 || arguments[1] === undefined ? 'f' : arguments[1];
  return x && y + x || function (x) {
    return foo(x, y + 'o');
  };
};
foo('a'); // "fa"
foo()('b'); // "fb"
foo()()('t'); // "foot"

Answer 3

function foo ( c ) {

  // Initialize the result
  var result = 'f';

  // Call the internal foo and return the result
  // Which will either be the function itself, or a string, depnding on 
  // whether or not a truthy argument was passed in
  return foo( c );

  function foo ( c ) {

      // If an argument was passed in, return the result
      if ( c )
          return result + c;

      // Otherwise append an 'o' to the result
      result += 'o';

      // and return the function so it can be called again
      return foo;
  }

}

Answer 4

如果你不能想出像@Iven Marquardt 这样的绝妙想法，那么闭包就可以完美地完成这项工作。

function Foo(){
  var count = 0,
        str = "";
  function f(a){
    if (!!a){
    str = "f"+"o".repeat(count)+a;
    count = 0;
    return str;
    }
  count++;
  return foo;
  }
  return f;
}
var foo = Foo();
foo('a')       // <- 'fa'
foo()('b')     // <- 'fob'
foo()()("t"))  // <- 'foot'

Answer 5

除了我之前的答案（它显示了解决此问题的一种天真的传统方法）之外，我还想单独添加一个单独的答案，因为我不希望这个好答案被忽视。 问题是，这个问题最合适的解决方案可能在于 ES6 默认值的一个最容易被忽视的特性。

调用函数时，如果未提供具有默认值的参数，则应用默认值。 （它不会变成“未定义”）

一旦你知道了这个功能，这个问题的答案就很简单了，只不过是一个衬里而已。

var foo = (c, o = "") => !!c ? "f"+o+c : c => foo(c, o+= "o")
foo("a");    //fa
foo()("b");  //fob
foo()()("t") //foot