JavaScript 中的函数式编程

函数式编程是一种编程范式，它强调将计算过程看作是数学函数（即没有副作用），并且避免改变状态和可变数据。在 JavaScript 中，函数式编程可以通过高阶函数、函数组合、柯里化和惰性计算等特性来实现。

高阶函数

JavaScript 中的函数是一等公民，因此我们可以将函数作为参数传递给另一个函数，或者将函数作为返回值返回。这样的函数被称为高阶函数。例如，以下是一个将函数作为参数传递的高阶函数：

function map(array, fn) {
  var result = [];
  for (var i = 0; i < array.length; i++) {
    result.push(fn(array[i]));
  }
  return result;
}

var numbers = [1, 2, 3];
var squared = map(numbers, function(x) {
  return x * x;
});
console.log(squared); // [1, 4, 9]

上面的 map 函数接受一个数组和一个函数作为参数，然后将数组中的每个元素传递给函数，将函数的返回值推入一个数组中，最后返回该数组。

函数组合

函数组合是将多个函数组合成一个函数的过程。这可以通过 compose 函数实现：

function compose() {
  var fns = arguments;
  return function(x) {
    var result = x;
    for (var i = fns.length - 1; i >= 0; i--) {
      result = fns[i](result);
    }
    return result;
  };
}

function add(x) {
  return x + 1;
}
function square(x) {
  return x * x;
}
var addThenSquare = compose(square, add);
console.log(addThenSquare(3)); // 16

上面的 compose 函数接受多个函数作为参数，并返回一个新函数。这个新函数按照参数的顺序将其输入值传递给多个函数，最后返回最后一个函数的返回值。

柯里化

柯里化是将一个接受多个参数的函数转换为一系列接受一个参数的函数的过程。这可以通过以下函数实现：

function curried(fn) {
  return function curriedFn(...args) {
    if (args.length >= fn.length) {
      return fn.apply(null, args);
    } else {
      return function(...args2) {
        return curriedFn.apply(null, args.concat(args2));
      };
    }
  };
}

function add(x, y) {
  return x + y;
}
var curriedAdd = curried(add);
console.log(curriedAdd(1)(2)); // 3

上面的 curried 函数接受一个函数，并返回一个具有相同功能的柯里化函数。

惰性计算

惰性计算是一种延迟计算的方式。它通过在必要时才计算值来提高性能。例如：

function createArray(length, fn) {
  var result = [];
  for (var i = 0; i < length; i++) {
    result[i] = fn(i);
  }
  return result;
}

function square(x) {
  return x * x;
}

var squares = createArray(10, square);

上面的 createArray 函数会立即计算 squares 数组中的所有值。如果 length 非常大，则这可能会导致性能问题。相反，我们可以采用惰性计算的方式：

function lazyCreateArray(length, fn) {
  var result = [];
  for (var i = 0; i < length; i++) {
    Object.defineProperty(result, i, {
      configurable: true,
      enumerable: true,
      get: function() {
        var value = fn(i);
        Object.defineProperty(result, i, {
          configurable: true,
          enumerable: true,
          value: value
        });
        return value;
      }
    });
  }
  return result;
}

var lazySquares = lazyCreateArray(10, square);

上面的 lazyCreateArray 函数会在访问 lazySquares 数组中的每个元素时计算该元素的值。这可以避免一次性计算所有值的问题。

总结

JavaScript 中的函数式编程是一种强调函数无副作用、避免状态和可变数据的编程范式。它可以使用高阶函数、函数组合、柯里化和惰性计算等特性来实现。这些特性可以提高代码的可读性、可维护性和可复用性。