Aitter's Blog

函数式编程之名词解释

函数式编程名词众多,可能有些我们在日常的编码中实践过,但并不知道他的学名,也有可能很多我们从来没有听说过,下面是一些常见的函数式编程中的名词说明

  • 纯函数 Purity
  • 函数柯里化 Currying
  • 偏函数 Partial Application
  • 惰性函数 Lazy evaluation
  • 函数组合 Function Composition
  • 高阶函数 Higher-Order Functions
  • 函数记忆 Memoize
  • 函数副作用 Side effects

纯函数 Purity

与外界交换数据只有唯一渠道——参数和返回值,并且函数的执行不会对外部环境产生副作用

var arr = [1,2,3,4,5];
// Array.slice是纯函数,因为它没有副作用,对于固定的输入,输出总是固定的
// 可以,这很函数式
xs.slice(0,3);
//=> [1,2,3]
xs.slice(0,3);
//=> [1,2,3]
// Array.splice是不纯的,它有副作用,对于固定的输入,输出不是固定的
// 这不函数式
xs.splice(0,3);
//=> [1,2,3]
xs.splice(0,3);
//=> [4,5]
xs.splice(0,3);
//=> []

函数副作用 Side effects

如果函数或表达式与其自身作用域之外的可变数据发生了读写操作,那么此时函数和表达式就产生了副作用

let greeting;
const greet = () => greeting = "Hi, " + window.name;
// greet() 执行时更改了外部环境的变量
greet();
// => "Hi, Brianne"
// new Date() 是可变数据
const differentEveryTime = new Date();
// 这里表示系统接收到的输入值是不确定的,是一种可变数据
console.log("IO is a side effect!");

偏函数 Partial Application

原函数的基础上预填充部分参数并返回的新函数

// 下面是一个创建偏函数的辅助函数
const partial = (f, ...args) => (...moreArgs) => f(...args, ...moreArgs);
const add3 = (a, b, c) => a + b + c;
// 预填充 (add3, 2, 3) 三个参数,空置最后一个参数,返回一个新的函数
const fivePlus = partial(add3, 2, 3); // (c) => 2 + 3 + c
fivePlus(4);
// => 9

惰性求值 Lazy evaluation

惰性求值,是一种按需执行的求值策略,只有需要某个值时才会执行相关的表达式。在函数式编程语言中,这一特性可用于构造无限列表。

const rand = function*() {
while (true) {
yield Math.random();
}
}
const randIter = rand();
randIter.next().value;
// 每次执行 next() 函数都会返回一个新的随机数
// 有且只有在执行 next() 的时候才会返回新值

函数柯里化 Currying

将一个接收多个参数的函数转化为单参数函数的方式
将接收多个参数的函数转换为一系列只接收一个参数的函数的过程

//比较容易读懂的ES5写法
var add = function(x){
return function(y){
return x + y
}
}
//ES6写法,也是比较正统的函数式写法
var add = x => (y => x + y);
//试试看
var add2 = add(2);
var add200 = add(200);
add2(2); // =>4
add200(50); // =>250

函数组合 Function Composition

接收多个函数作为参数并返回一个新函数的方式

const add = function ( x, y ) {
return x + y;
};
const square = function ( x ) {
return x * x;
};
const composeTwo = function ( f, g ) {
return function ( x, y ) {
return g( f ( x, y ) );
};
};
const addThenSquare = composeTwo( add, square );

高阶函数 Higher-Order Functions

函数接收一个或多个函数做为参数,并返回一个函数

const numbers = [1, 2, 3];
const print = function ( input ) {
console.log( input );
};
numbers.forEach( print );

函数记忆 Memoize

得益于纯函数的特性,相同的参数可能返回相同的结果,那么就可以缓存参数对对应的结果,以减少反复的计算,从而提高性能

var squareNumber = memoize(function(x){ return x*x; });
squareNumber(4);
//=> 16
squareNumber(4); // 从缓存中读取输入值为 4 的结果
//=> 16
var memoize = function(f) {
var cache = {};
return function() {
var arg_str = JSON.stringify(arguments);
cache[arg_str] = cache[arg_str] || f.apply(f, arguments);
return cache[arg_str];
};
};
var memoize = function(func, hasher) {
var memoize = function(key) {
var cache = memoize.cache;
var address = '' + (hasher ? hasher.apply(this, arguments) : key);
if (!cache[address]) {
cache[address] = func.apply(this, arguments);
}
return cache[address];
};
memoize.cache = {};
return memoize;
};
var count = 0;
var fibonacci = function(n){
count++;
return n < 2? n : fibonacci(n-1) + fibonacci(n-2);
};
for (var i = 0; i <= 10; i++){
fibonacci(i)
}
console.log(count) // 453
var count = 0;
var fibonacci = function(n) {
count++;
return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
};
fibonacci = memoize(fibonacci)
for (var i = 0; i <= 10; i++) {
fibonacci(i)
}
console.log(count) // 12

pointfree style

point-free style 是一种不显式向函数传递参数的代码风格,通常需要柯里化和高阶函数来实现

// 需求:输入 'kevin',返回 'HELLO, KEVIN'。
// 非 pointfree,因为提到了数据:name
var greet = function(name) {
return ('hello ' + name).toUpperCase();
}
// pointfree
// 先定义基本运算,这些可以封装起来复用
var toUpperCase = function(x) { return x.toUpperCase(); };
var hello = function(x) { return 'HELLO, ' + x; };
var greet = compose(hello, toUpperCase);
greet('kevin');