Función de curado y composición de la función de componer

Implementación de curry

La síntesis de funciones JS es la operación de combinar múltiples funciones de un solo parámetro en una función de múltiples parámetros. Por ejemplo, si a (x) y b (x) se combinan en a (b (x)), se denominan colectivamente f (a, b, x). Tenga en cuenta que tanto a (x) como b (x) aquí solo pueden recibir un parámetro. Si recibe varios parámetros, como a (x, y) y b (a, b, c), la síntesis de funciones es más problemática.

En este momento, se utiliza la función de curado. El llamado curado consiste en transformar una función de múltiples parámetros en una función de un solo parámetro. Con la operación de curado, podemos lograr que todas las funciones reciban un solo parámetro.

var add = function (x) {  //柯里化
    return function (y) {
        return x + y;
    }
}
console.log(add(2) (6));  //8，连续调用

//柯里化函数
function curry (fn) {
    var _argLen = fn.length;  //记录原始函数的形参个数
    var _args = [].slice.call(arguments, 1);  //把传入的第2个及以后参数转换为数组
    function wrap () {  //curry函数
        //把当前参数转换为数组，与前面参数进行合并
        _args = _args.concat([].slice.call(arguments));
        function act () {  //参数处理函数
            //把当前参数转换为数组，与前面参数进行合并
            _args = _args.concat([].slice.call(arguments));
            //如果传入参数总和大于等于原始参数的个数，触发执行条件
            if ((_argLen == 0 && arguments.length == 0) ||
                (_argLen > 0 && _args.length >= _argLen)) {
                //执行原始函数，并把每次传入参数传入进去，返回执行结果，停止curry
                return fn.apply(null, _args);
            }
            return arguments.callee;
        }
        //如果传入参数大于等于原始函数的参数个数，即触发了执行条件
        if ((_argLen == 0 && arguments.length == 0) ||
            (_argLen > 0 && _args.length >= _argLen)) {
            //执行原始函数，并把每次传入参数传入进去，返回执行结果，停止curry
            return fn.apply(null, _args);
        }
        act.toString = function () {  //定义处理函数的字符串表示为原始函数的字符串表示
            return fn.toString();
        }
        return act;  //返回处理函数
    }
    return wrap;  //返回curry函数
}

Realización de la función de síntesis

En la programación funcional de JS, a menudo se ven las siguientes operaciones de expresión.

a(b(c(x)));

Esta es una llamada de función de varias capas de "estilo repollo", pero no muy elegante. Para resolver el problema de anidamiento de las llamadas a funciones multinivel, necesitamos usar la composición de funciones. El formato de sintaxis es el siguiente:

var f = compose(a, b, c);  //合成函数
f(x);

递归实现：

const compose = function (...funcs) {
  let len = funcs.length,
    count = len - 1,
    result = null;
  // 首先compse 返回的是一个函数
  return function fn(...args) {
    // 函数体里就是不断执行args函数，将上一个函数的执行结果作为下一个执行函数的输入参数，需要一个count来记录args函数列表的执行情况
    result = args[count].apply(this, args);
    console.log(result);
    // 递归退出条件
    if (count <= 0) {
      count = len - 1;
    } else {
      count--;
      return fn.call(null, result);
    }
  };
};

Implementación iterativa:

function compose(...fns) {
  let isFirst = true;
  return (...args) => {
    return fns.reduceRight((result, fn) => {
      if (!isFirst) return fn(result);
      isFirst = false;
      return fn(...result);
    }, args);
  };
}

Función de curado y composición de la función de componer

Supongo que te gusta