javascript - Comment écrire cette question en js?

Question

1. Il y a des paramètres fn mentionnés ici. Je sais qu'ils doivent être écrits avec des arguments et renvoyer function(){} dans la fonction, mais je n'arrive tout simplement pas à le comprendre

.

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

La première façon d'écrire :

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

Deuxième façon d'écrire :

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

J'ai amélioré le code de @Xiaoming. Vous pouvez désormais modifier l'ordre des méthodes à exécuter à volonté. Assurez-vous simplement qu'il y a suffisamment de paramètres

.

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

Une solution plus générale, mais l'écriture est relativement faible...

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

Je posterai également une méthode d'écriture relativement faible, j'espère que vous pourrez me corriger

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

Combinez les deux méthodes d'écriture de @Zhishui :

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