函数式编程

函数式编程

函数是可以接受并且返回任何类型的值。一个函数如果可以接受或返回一个甚至多个函数，它被叫做高阶函数。

1.核心特点

1. 不可变性：函数式编程强调数据不可变性，一旦定义了一个值，就不能再改变它的值。这样可以避免因为副作用带来的不可预测性。

2. 函数作为一等公民：在函数式编程中，函数被视为一等公民，就像其他数据类型一样，可以赋值给变量、作为函数的参数或返回值。

3. 无副作用：函数式编程强调无副作用，即函数的执行不会对外部状态造成任何影响，只通过输入和输出来处理数据。

4. 高阶函数：函数式编程可以使用高阶函数，即接受函数作为参数或返回函数的函数，来实现抽象和复用。

5. 延迟计算：函数式编程通常采用延迟计算，也就是只在需要的时候才计算表达式的值，这可以减少不必要的计算。

6. 递归：函数式编程经常使用递归来处理数据结构，例如列表和树。

// 定义一个函数式编程的解决方案
function doubleEvenNumbers(numbers) {
  return numbers
    .filter(function(num) {
      return num % 2 === 0; // 保留偶数
    })
    .map(function(num) {
      return num * 2; // 将偶数加倍
    });
}

// 调用函数并输出结果
var numbers = [1, 2, 3, 4, 5, 6];
var doubledEvens = doubleEvenNumbers(numbers);
console.log(doubledEvens); // [4, 8, 12]

// 定义一个命令式编程的解决方案
function doubleEvenNumbers(numbers) {
  var doubledEvens = [];

  for (var i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 === 0) { // 保留偶数
      doubledEvens.push(numbers[i] * 2); // 将偶数加倍并添加到结果数组中
    }
  }

  return doubledEvens;
}

// 调用函数并输出结果
var numbers = [1, 2, 3, 4, 5, 6];
var doubledEvens = doubleEvenNumbers(numbers);
console.log(doubledEvens); // [4, 8, 12]

2.纯函数

1. 输入参数决定函数返回值，相同的输入参数始终返回相同的输出结果。

2. 函数在执行过程中没有副作用，也就是说不会对系统环境造成任何影响，如修改输入参数、改变全局变量、文件读写、网络请求等操作

function multiply(a, b) {
  return a * b;
}

3.柯里化

柯里化（Currying）是一种函数式编程技术，它将接收多个参数的函数转化为接收一个单一参数的函数序列

function add(a, b) {
  return a + b;
}

// 将 add 函数转换成柯里化函数
function curriedAdd(a) {
  return function(b) {
    return a + b;
  }
}

const sum = curriedAdd(1)(2); // 3

优点

1. 灵活性：柯里化函数能够接收单个参数，并且返回新的函数，这使得函数更加灵活和易于组合。

2. 代码复用：柯里化函数能够创建一个新的函数，这使得我们可以将函数的一部分封装起来并重用它们。

3. 可读性：柯里化函数能够更好地表达函数的含义，使代码更加易于理解和维护

实现通用柯里化

const curry = (fn) => { // 定义 curry 函数，接收一个函数 fn 作为参数
  const arity = fn.length; // 获取 fn 的参数个数，即 fn 的元数

  return function curried(...args) { // 定义新函数 curried，它可以接收任意数量的参数
    if (args.length < arity) { // 如果当前接收的参数个数小于 fn 的元数
      return function(...rest) { // 则返回一个新函数，接收剩余的参数 rest
        return curried(...args.concat(rest)); // 递归调用 curried，并将之前的参数 args 与当前的参数 rest 合并
      };
    } else { // 如果当前接收的参数个数等于 fn 的元数
      return fn.apply(null, args); // 则直接调用 fn 并传入所有参数 args
    }
  };
};

1. 使用 fn.length 获取函数 fn 的参数个数，即函数的元数。这个参数个数可以帮助我们判断柯里化的过程何时结束，需要一次性调用原始函数并返回结果。

2. 返回一个新的函数 curried，该函数可以接收任意数量的参数，并根据参数个数判断是否需要继续柯里化或直接调用原始函数。
如果当前接收的参数个数小于 arity，则说明还需要继续柯里化，我们返回一个新的函数，该函数接收剩余的参数 rest 并将其与之前的参数 args 合并，然后递归调用 curried 函数。
如果参数个数等于 arity，则说明已经接收了所有参数，我们直接调用原始函数 fn 并传入所有参数 args。

1. 实现一个通用的柯里化函数 curry，它接收一个函数作为参数，返回一个新的函数，该新函数可以对原始函数进行柯里化。

2. 实现一个 add 函数的柯里化版本 addCurry，使得该函数可以支持以下用法：

addCurry(1)(2)(3)(); // 6
addCurry(1)(2)(3)(4)(); // 10
addCurry(1, 2, 3)(); // 6
addCurry(1)(2, 3)(4)(); // 10

function addCurry(...args) {
  const sum = args.reduce((a, b) => a + b, 0);
  
  function curry(...innerArgs) {
    if (innerArgs.length === 0) {
      return sum;
    } else {
      return addCurry(sum, ...innerArgs);
    }
  }
  
  curry.valueOf = function() {
    return sum;
  }
  
  return curry;
}

1. 实现一个通用的 compose函数，它接收任意数量的函数作为参数，返回一个新的函数，该新函数可以将所有传入的函数按照从右到左的顺序组合成一个新的函数。

const f = (x) => x + 1;
const g = (x) => x * 2;
const h = (x) => x / 3;

const composed = compose(h, g, f);

console.log(composed(1)); // 1.3333333333333333

1. 实现一个函数 memoize，该函数接收一个函数作为参数，并返回一个新的函数，该新函数可以缓存原始函数的计算结果，并在下次相同的参数调用时直接返回缓存的结果

const fibonacci = function(n) {
  if (n < 2) {
    return n;
  } else {
    return fibonacci(n - 1) + fibonacci(n - 2);
  }
};

const memoizedFibonacci = memoize

4.compose函数和pipeline函数

compose函数

var compose = function(f,g) {
  return function(x) {
    return f(g(x));
  };
};

// 例子
var toUpperCase = function(x) { return x.toUpperCase(); };
var exclaim = function(x) { return x + '!'; };
var shout = compose(exclaim, toUpperCase);

shout("send in the clowns");
//=> "SEND IN THE CLOWNS!"

javascriptCopy code
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue);
console.log(sum); // 15

javascriptCopy code
const numbers = [1, 2, 3, 4, 5];
const initialValue = 10;
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, initialValue);
console.log(sum); // 25