#JavaScript 函数组合实现

#问题描述

编写一个名为 compose 的函数，它接受一个包含多个整数处理函数的数组作为输入，返回一个新的函数。这个新的函数是输入数组中所有函数的 复合函数 ，按照从右到左的顺序执行。

• 如果输入数组为空，则复合函数为恒等函数，即 f(x) = x。
• 否则，对于输入数组 [f1, f2, ..., fn]，其复合函数定义为 fn(x) = f1(f2(...(fn(x))))。

#示例

#示例 1

          
1
2
3
4
5
6
7
8
9
10
11
12
13
          输入：
functions = [x => x + 1, x => x * x, x => 2 * x], 
x = 4

输出：
65

解释：
从右向左计算...
Starting with x = 4.
2 * (4) = 8
(8) * (8) = 64
(64) + 1 = 65

        

#示例 2

          
1
2
3
4
5
6
7
8
9
10
11
12
          输入：
functions = [x => 10 * x, x => 10 * x, x => 10 * x], 
x = 1

输出：
1000

解释：
从右向左计算...
10 * (1) = 10
10 * (10) = 100
10 * (100) = 1000

        

#示例 3

          
1
2
3
4
5
6
7
8
9
          输入：
functions = [], 
x = 42

输出：
42

解释：
空函数列表的复合函数就是恒等函数

        

#约束条件

• -1000 <= x <= 1000
• 0 <= functions.length <= 1000
• 所有函数都接受一个整数作为输入并返回一个整数

#解决方案（解法一：使用 for 循环）

          
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
          type F = (x: number) => number;

function compose(functions: F[]): F {
  return function(x) {
    let result = x;
    for (let i = functions.length - 1; i >= 0; i--) {
      result = functions[i](result);
    }

    return result;
  };
};

// 示例用法
const fn = compose([x => x + 1, x => 2 * x]);
fn(4); // 输出 9

        

#解决方案（解法二：使用 reduceRight 方法）

          
1
2
3
4
5
6
7
8
9
10
11
12
13
          type F = (x: number) => number;

function compose(functions: F[]): F {
  return function(x) {
    return functions.reduceRight((prev, currentFn) => {
      return currentFn(prev);
    }, x);
  };
};

// 示例用法
const fn = compose([x => x + 1, x => 2 * x]);
fn(4); // 输出 9