Question

我正在尝试在JS中构建一个函数，该函数具有由基于用户传递的参数的不同嵌套函数组成的返回。

function addA(otherFunction)
{
//gets the result from some base function and modifies it
//e.g. +1
}

function addB(otherFunction)
{
//does the same thing as addA, except different values. Consider it a variation of addA.
//eg. -1
}

function constr(input)
{
//based on the chars in input, we will recursively select a new function to be applied.
//the value of this function should be a function
if (...) return addA(constr(shorterInput))
if (*last char) return addA
if (*last char) return addB
if (...) return addB(constr(shorterInput))
}

到目前为止，我的脚本正在将addA和addB识别为函数。但是当它将两个函数串在一起时，例如

addB(addA)

类型变得不确定。任何人都可以告诉我为什么它没有注册为函数和/或返回嵌套函数的正确方法。谢谢！

编辑：这是真正的代码：

function cons(a,b)
{
  return function (selector) {
    return selector(a,b);
  };
}

function a(list)
{
  function aHelper(a,b)
  {
    return a
  }
  return list(aHelper);
}

function d(list)
{
  function dHelper(a,b)
  {
    return b
  }
  return list(dHelper);
}

function abc(input)
{
  if (input.length==0 || input==null) return null;
  var x=input.charAt(input.length-1);
  if (x==='a') 
  {
    if (input.length>1) 
    {
      var z=a(abc(input.substr(0,input.length-1)));
      return z;
    }
      return a;
  }
  if (x==='d')
  {
    if (input.length>1) 
    {
      var z=d(abc(input.substr(0,input.length-1)));
      return z;
    }
    return d;
  }
}
function show(list) {
  var sval;
  if (list == null) return '()';
  else if (typeof list!='string')
  {
    sval = '(' + show(a(list)) + ' ' + show(d(list)) + ')';
  }
  else 
  {
    sval=list;
  }
  return sval;
}

var func=abc('ad');
var func2=abc('a');
var list=cons('a',cons('b','c'));
console.log(typeof func);
console.log(typeof func2);
console.log(typeof list);
console.log(typeof func2(list));
console.log(typeof func(list));

Answer 1

您的函数abc应该返回一个可以处理列表的函数，例如a或d。但是，您只能在7个案例中的2个中匹配该签名：

return a，return d没问题
return null - 这不是可调用的值
z = d(…); return z确实会返回一个列表
z = a(…); return a会返回列表中的元素（无论何种类型）
d(abc(…))和a(abc(…))使用abc，就好像它会返回一个列表一样

正确的实现如下：

function abc(directions) {
    if (directions.length == 0) {
       return function id(list) { return list; }; // a function that does nothing
    }
    var f = directions[0] == 'a' ? car : cdr; // ignoring other values, you might also throw an error
    var processRest = abc(input.slice(1));

    return function(list) { // make a function to process a list
        var z = f(list); // do the current operation
        return processRest(z); // do the rest of operations
    };
}

在高阶函数组合的帮助下，甚至更好/更短：

function id(x) { return x; }
function compose(f, g) {
    if (f == id) return g;
    if (g == id) return f;
    return function(x) { return f(g(x)); };
}
function abc(dirs) {
    return !dirs.length ? id : compose(abc(dirs.slice(1)), dirs[0]=='a'?car:cdr);
}

递归返回函数以形成嵌套函数 - Javascript

1 个答案: