javascript函数式编程（一）

时间：2024-01-23 20:15:25

一、引言

　　javascript函数式编程在最近两年来频繁的出现在大众的视野，越来越多的框架（react，angular，vue等）标榜自己使用了函数式编程的特性，好像一旦跟函数式编程沾边，就很高大上一样，而且还有一些专门针对函数式编程的框架和库，比如：RxJS、cycleJS、ramdaJS、lodashJS、underscoreJS等。近年来随着技术的发展，函数式编程已经在实际生产中发挥巨大的作用了，越来越多的语言开始加入闭包，匿名函数等非常典型的函数式编程的特性，从某种程度上来讲，函数式编程正在逐步“同化”命令式编程。所以这里有必要介绍一下函数式编程的知识和特性。

二、纯函数（函数式编程的基石）

　　如果你还记得一些初中数学知识的话，函数f的定义就是，对于输入x产生一个输出y=f(x)。这便是一种最简单的纯函数。所以纯函数的定义是：即对于相同的输入，永远会得到相同的输出，而且没有任何可观察的副作用。

　　副作用可能包含，但不限于：

　　1.更改文件系统
　　2.往数据库插入记录
　　3.发送一个 http 请求
　　4.可变数据
　　5.打印/log
　　6.获取用户输入
　　7.DOM 查询
　　8.访问系统状态

　　下面举个栗子，比如在javascript中对数组的操作，有些是纯的，有些是不纯的：

var xs = [1,2,3,4,5];

// 纯的
xs.slice(0,3);
//=> [1,2,3]

xs.slice(0,3);
//=> [1,2,3]

xs.slice(0,3);
//=> [1,2,3]


// 不纯的
xs.splice(0,3);
//=> [1,2,3]

xs.splice(0,3);
//=> [4,5]

xs.splice(0,3);
//=> []

　　在函数式编程中，我们想要的是像slice这样的纯函数，而不是像 splice 这样每次调用后都把数据弄得一团糟的函数。

　　再看另外一个栗子：

// 不纯的
var minimum = 21;

var checkAge = function(age) {
  return age >= minimum;
};


// 纯的
var checkAge = function(age) {
  var minimum = 21;
  return age >= minimum;
};

　　在不纯的版本中，checkAge 的结果将取决于 minimum这个可变变量的值。换句话说，它取决于系统状态。在大型系统中，这种对于外部状态的依赖是造成系统复杂性大大提高的主要原因。

　　可以看到，纯的checkAge把minimum硬编码到函数内部，导致函数扩展性差，我们可以在后面的柯里化中看到如何优雅的使用函数式解决这个问题。

 　　使用纯函数不仅可以降低系统复杂度，还有很多其他特性，比如可缓存性：

var squareNumber  = memoize(function(x){ return x*x; });

squareNumber(4);
//=> 16

squareNumber(4); // 从缓存中读取输入值为 4 的结果
//=> 16

三、函数柯里化

　　curry 的概念很简单：将一个低阶函数转换为高阶函数的过程就叫柯里化。

　　

　　比如对于加法操作var add = (x, y) => x + y，我们可以这样柯里化：

//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

 　　对于加法这种极其简单的函数来说，柯里化并没有什么用处。

　　还记得上面的checkAge函数吗，我们可以这样柯里化它：

var checkage = min => (age => age > min);
var checkage18 = checkage(18);
checkage18(20);
// =>true

事实上，函数柯里化是一种“预加载”函数的方法，通过传递一到两个参数调用函数，就能得到一个记住了这些参数的新函数。从某种意义上来讲，这是一种对参数的缓存，是一种非常高效的编写函数的方法：

import { curry } from 'lodash';

//首先柯里化两个纯函数
var match = curry((reg, str) => str.match(reg));
var filter = curry((f, arr) => arr.filter(f));

//判断字符串里有没有空格
var haveSpace = match(/\s+/g);

haveSpace("ffffffff");
//=>null

haveSpace("a b");
//=>[" "]

filter(haveSpace, ["abcdefg", "Hello World"]);
//=>["Hello world"]

四、函数组合

　　学会了使用纯函数以及如何把它柯里化之后，我们会很容易写出这样的“包菜式”代码：

h(g(f(x)));

　　虽然这也是函数式代码，但它依然存在某种意义上的不优雅。为了解决函数嵌套问题，我们需要用到函数组合。

//两个函数的组合
var compose = function(f, g) {
    return function(x) {
        return f(g(x));
    };
};

//或者
var compose = (f, g) => (x => f(g(x)));

var add1 = x => x + 1;
var mul5 = x => x * 5;

compose(mul5, add1)(2);
// =>15

　　我们定义的compose就像双面胶一样，可以把任何两个纯函数结合到一起。当然你也可以扩展出组合三个函数的“三面胶”，甚至“四面胶”“N面胶”。

　　这种灵活的组合可以让我们像拼积木一样来组合函数式的代码：

var first = arr => arr[0];
var reverse = arr => arr.reverse();

var last = compose(first, reverse);

last([1,2,3,4,5]);
// =>5

五、声明式和命令式代码

 　　命令式代码的意思是，我们通过编写一条条指令告诉计算机去执行一系列动作，这其中一般会涉及到很多繁杂的细节。

　　而声明式则要优雅的多，我们通过书写表达式的方式声明我们要干什么，而不是通过一步步的指示。

const doubleMap = numbers => {
    const doubled = [];
    for (let i = 0; i < numbers.length; i++) {
        doubled.push(numbers[i] * 2);
    }
    return doubled;
};

doubleMap([2, 3, 4]); //[4, 6, 8]

　　命令式的写法要求先实例化一个数组，然后对numbers数组进行for循环遍历，手动命名、判断、增加计数器，就像你开了一辆零部件全部暴露在外的汽车一样。这不是优雅的程序员应该做的。

　　声明式的写法是一个表达式，如何进行计数器迭代，返回的数组如何收集，这些细节都隐藏了起来。它指明的是做什么，而不是怎么做。除了更加清晰和简洁之外，map 函数还可以进一步独立优化，甚至用解释器内置的速度极快的 map 函数，这么一来我们主要的业务代码就无须改动了。

const doubleMap = numbers => numbers.map(n => n * 2);

doubleMap([2, 3, 4]); //[4, 6, 8]

　　函数式编程的一个明显的好处就是这种声明式的代码，对于无副作用的纯函数，我们完全可以不考虑函数内部是如何实现的，专注于编写业务代码。优化代码时，目光只需要集中在这些稳定坚固的函数内部即可。

　　相反，不纯的不函数式的代码会产生副作用或者依赖外部系统环境，使用它们的时候总是要考虑这些不干净的副作用。在复杂的系统中，这对于程序员的心智来说是极大的负担。

六、Point Free

　　有了柯里化和函数组合的基础知识，下面介绍一下Point Free这种代码风格。

　　细心的话你可能会注意到，之前的代码中我们总是喜欢把一些对象自带的方法转化成纯函数：

var map = (f, arr) => arr.map(f);

var toUpperCase = word => word.toUpperCase();

　　这种做法是有原因的。

　　Point Free这种模式现在还暂且没有中文的翻译，用中文解释的话大概就是，不要命名转瞬即逝的中间变量，比如：

//这不Piont free
var f = str => str.toUpperCase().split(' ');

　　这个函数中，我们使用了 str 作为我们的中间变量，但这个中间变量除了让代码变得长了一点以外是毫无意义的。下面改造一下这段代码：

var toUpperCase = word => word.toUpperCase();
var split = x => (str => str.split(x));

var f = compose(split(' '), toUpperCase);

f("abcd efgh");
// =>["ABCD", "EFGH"]

　　这种风格能够帮助我们减少不必要的命名，让代码保持简洁和通用。当然，为了在一些函数中写出Point Free的风格，在代码的其它地方必然是不那么Point Free的，这个地方需要自己取舍。

七、示例应用

　　拥有了以上的知识，我们是时候该写一个示例应用了。

　　这里我们使用了 ramda ，没有用 lodash 或者其他类库。ramda 提供了 compose、curry 等很多函数。

　　我们的应用将做四件事：

　　  1.根据特定搜索关键字构造 url
　  　2.向 flickr 发送 api 请求
　　  3.把返回的 json 转为 html 图片
　　  4.把图片放到屏幕上

　　上面提到了两个不纯的动作，即从 flickr 的 api 获取数据和在屏幕上放置图片这两件事。我们先来定义这两个动作，这样就能隔离它们了。这里我们只是简单包装了一下jQuery的getJSON函数，把它变为一个 curry 函数，还有就是把参数位置也调换了下，我们把它们放在 Impure 命名空间下以用来隔离，这样我们就知道它们都是危险函数。

　　运用函数柯里化和函数组合的技巧，我们就可以创建一个函数式的实际应用了：

 看看，多么美妙的声明式规范啊，只说做什么，不说怎么做。现在我们可以把每一行代码都视作一个等式，变量名所代表的属性就是等式的含义。

八、总结

我们已经见识到如何在一个小而不失真实的应用中运用新技能了，但是异常处理以及代码分支呢？如何让整个应用都是函数式的，而不仅仅是把破坏性的函数放到命名空间下？如何让应用更安全更富有表现力？我会在下一篇文章中介绍函数式编程的更加高阶一些的知识，例如Functor、Monad、Applicative等概念。

 

相关文章