请问这个题怎么用js写呢?

Question

1.这里说得fn个参数，我知道应该跟arguments和在函数里面用return function(){}这种方式来写，但是就是写不明白

function add(a,b){
    return a+b;
}
function square(a){
    return a*a;
}
function plusOne(c){
    return c+1;
}
//var result = plusOne(square(add(1,2))); //这种的直接的转化成下面的不会
//alert(result);

var addSquareAndPlusOne = composite(add,square,plusOne);
function composite(add,square,plusOne){
    return function(){
      //这里怎么写呢？谢谢指导
    }
}
addSquareAndPlusOne(1,2);

Answer 1

第一种写法：

const composite = (...args) => {
    return (...arguments) => {
        return args.reduce((memo, current) => {
          return current(typeof memo === 'function' ? memo.apply(memo, arguments) : memo)
        })
    }
}

第二种写法：

const composite = (...args) => {
  return (...arguments) => {
    const init = args[0].apply(null, arguments)
    return args.slice(1).reduce((memo, current) => {
      return current(memo)
    }, init)
  }
}

Answer 2

改进了一下 @小明 的代码，现在可以随意改变需要执行方法的顺序了，只需要保证有足够的参数就可以了

var composite = (...opts) => (...args)=>opts.reduce((curr, opt)=>[opt.apply(opt, curr), ...curr.slice(opt.length)], args)[0];

composite(add,square,plusOne)(1,2); // 10
composite(square,plusOne,add)(1,2); // 4

Answer 3

function composite(...args) {

    var fn = args[0];

    args = args.slice(1);

    return function() {
        
        var pr = fn.apply(this, arguments);

        return args.reduce((pre,cur)=>{
            return cur(pre)
        }
        , pr)
    }

}

Answer 4

通用一点的解，但是写的比较low...

function add(a,b){
    return a+b;
}
function square(a){
    return a*a;
}
function plusOne(c){
    return c+1;
}
// plusOne(square(add()))
var addSquareAndPlusOne = composite(add,square,plusOne);
function composite(){
    var slice = Array.prototype.slice,
        fns = slice.call(arguments),
        fnl = fns.length;

    if(fnl === 0) return null;

    return function () {
        var i = 1, ret = null;
        // console.log(fns,fnl)
        if(fnl > 2) {
            while(i < fnl) {
                // console.log(i)
                ret = i === 1 ? fns[i](fns[i - 1].apply(null, arguments)) : fns[i](ret);
                i++;
            }
            return ret;
        } else {
            return fns[0].apply(null, arguments);
        }
    }
}
addSquareAndPlusOne(1,2);

Answer 5

我也来贴一个比较low的的写法，希望多多指正

var startParam=null;
  var o={
    f1:function (a,b){
      return (a+b);
    },
    f2:function (a,b){

      return (a-b);
    },
    f3:function (a,b){
      return (a*b);
    }
  };


function composite(fa,fb,fc){
  var args=arguments;
  for(var i=0;i<arguments.length;i++){
    if(i==0){
      (function(i){
        o['f'+(i+1)]=function(){
         return (startParam=args[i].apply(undefined,arguments));
      }})(i)
    }else{
      (function(i){
        o['f'+(i+1)]=function(){
         return (startParam=args[i].apply(undefined,[startParam].concat([].slice.call(arguments))));
      }})(i)
    }
  }
 
}
  composite(o.f1,o.f2,o.f3)
  alert(o.f1(1,1));
  alert(o.f2(3));
  alert(o.f3(4));

Answer 6

把 @止水 同学的两种写法结合一下：

const composite = (...args) => {
    return (...arguments) => {
        return args.reduce((memo, current) => current.apply(current, [].concat(memo)), arguments)
    }
}