上一篇文章裡我們提到了純函數的概念,所謂的純函數就是,對於相同的輸入,永遠會得到相同的輸出,而且沒有任何可觀察的副作用,也不依賴外部環境的狀態(我偷懶複製過來的)。
但是實際的程式設計中,特別是前端的程式設計範疇裡,「不依賴外在環境」這個條件是根本不可能的,我們總是不可避免地接觸到DOM、AJAX 這些狀態隨時都在變化的東西。所以我們需要用更強大的技術來幹這些髒活。
如果你熟悉jQuery 的話,應該還記得,$(…) 傳回的物件並不是一個原生的DOM 對象,而是對於原生物件的一種封裝:
var foo = $('#foo'); foo == document.getElementById('foo'); //=> false foo[0] == document.getElementById('foo'); //=> true
這在某種意義上就是一個「容器」(但它不是函數式)。
接下類別我們會看到,容器為函數式程式設計裡普通的變數、物件、函數提供了一層極其強大的外衣,賦予了它們一些很驚豔的特性,就好像Tony Stark 的鋼鐵外衣,Dva 的機甲,明日香的2號機一樣。
下面我們就來寫一個最簡單的容器吧:
var Container = function(x) { this.__value = x; } Container.of = x => new Container(x); //试试看 Container.of(1); //=> Container(1) Container.of('abcd'); //=> Container('abcd')
我們呼叫 Container.of 把東西裝進容器裡之後,由於這一層外殼的阻擋,普通的函數就對他們不再起作用了,所以我們需要加一個介面來讓外部的函數也能作用到容器裡面的值:
Container.prototype.map = function(f){ return Container.of(f(this.__value)) }##我們可以這樣使用它:
Container.of(3) .map(x => x + 1) //=> Container(4) .map(x => 'Result is ' + x); //=> Container('Result is 4')
鍊式呼叫』,這也是我們的第一個 Functor。
Functor(函子)是實作了 map 並遵守一些特定規則的容器類型。
也就是說,如果我們要將普通函數應用到一個被容器包裹的值,那麼我們首先需要定義一個叫Functor 的資料類型,在這個資料類型中需要定義如何使用map 來應用這個普通函數。
把東西裝進一個容器,只留出一個介面map 給容器外的函數,這麼做有什麼好處呢?
本質上,Functor 是一個對於函數呼叫的抽象,我們賦予容器自己去呼叫函數的能力。當map 一個函數時,我們讓容器自己來運行這個函數,這樣容器就可以自由地選擇何時何地如何操作這個函數,以致於擁有惰性求值、錯誤處理、非同步呼叫等等非常牛掰的特性。
舉個例子,我們現在為map 函數新增一個檢查空值的特性,這個新的容器我們稱之為Maybe(原型來自於Haskell) :
var Maybe = function(x) { this.__value = x; } Maybe.of = function(x) { return new Maybe(x); } Maybe.prototype.map = function(f) { return this.isNothing() ? Maybe.of(null) : Maybe.of(f(this.__value)); } Maybe.prototype.isNothing = function() { return (this.__value === null || this.__value === undefined); } //试试看 import _ from 'lodash'; var add = _.curry(_.add); Maybe.of({name: "Stark"}) .map(_.prop("age")) .map(add(10)); //=> Maybe(null) Maybe.of({name: "Stark", age: 21}) .map(_.prop("age")) .map(add(10)); //=> Maybe(31)看了這些程式碼,覺得鍊式呼叫總是要輸入一堆 .map(…) 很煩吧?這個問題很好解決,還記得我們上一篇文章介紹的柯里化嗎? 有了柯里化這個強大的工具,我們可以這樣寫:
import _ from 'lodash'; var compose = _.flowRight; var add = _.curry(_.add); // 创造一个柯里化的 map var map = _.curry((f, functor) => functor.map(f)); var doEverything = map(compose(add(10), _.property("age"))); var functor = Maybe.of({name: "Stark", age: 21}); doEverything(functor); //=> Maybe(31)二、錯誤處理、Either現在我們的容器能做的事情太少了,它甚至連做簡單的錯誤處理都做不到,現在我們只能類似這樣處理錯誤:
try{ doSomething(); }catch(e){ // 错误处理 }#try/catch/throw 並不是「純粹」的,因為它從外部接管了我們的函數,並且在這個函數出錯時拋棄了它的返回值。這不是我們所期望的函數式的行為。 如果你對 Promise 熟悉的話應該還記得,Promise 是可以呼叫 catch 來集中處理錯誤的:
doSomething() .then(async1) .then(async2) .catch(e => console.log(e));對於函數式程式設計我們也可以做同樣的操作,如果執行正確,那麼就回傳正確的結果;如果錯誤,就回傳一個用來描述錯誤的結果。這個概念在 Haskell 中稱為 Either 類,Left 和 Right是它的兩個子類別。我們用JS 來實現一下:
// 这里是一样的=。= var Left = function(x) { this.__value = x; } var Right = function(x) { this.__value = x; } // 这里也是一样的=。= Left.of = function(x) { return new Left(x); } Right.of = function(x) { return new Right(x); } // 这里不同!!! Left.prototype.map = function(f) { return this; } Right.prototype.map = function(f) { return Right.of(f(this.__value)); }下面來看看 Left 和 Right 的差異:
#
Right.of("Hello").map(str => str + " World!"); // Right("Hello World!") Left.of("Hello").map(str => str + " World!"); // Left("Hello")
Left 和Right 唯一的差異就在於map 方法的實現,Right.map 的行為和我們之前提到的map 函數一樣。但是 Left.map 就很不同了:它不會對容器做任何事情,只是很簡單地把這個容器拿進來又丟出去。這個特性意味著,Left 可以用來傳遞一個錯誤訊息。
var getAge = user => user.age ? Right.of(user.age) : Left.of("ERROR!"); //试试 getAge({name: 'stark', age: '21'}).map(age => 'Age is ' + age); //=> Right('Age is 21') getAge({name: 'stark'}).map(age => 'Age is ' + age); //=> Left('ERROR!')
Left 可以讓呼叫鏈中任一環的錯誤立刻回到呼叫鏈的尾部,這給我們錯誤處理帶來了很大的方便,再也不用一層又一層的try/catch。
Left 和 Right 是 Either 类的两个子类,事实上 Either 并不只是用来做错误处理的,它表示了逻辑或,范畴学里的 coproduct。但这些超出了我们的讨论范围。
下面我们的程序要走出象牙塔,去接触外面“肮脏”的世界了,在这个世界里,很多事情都是有副作用的或者依赖于外部环境的,比如下面这样:
function readLocalStorage(){ return window.localStorage; }
这个函数显然不是纯函数,因为它强依赖外部的 window.localStorage 这个对象,它的返回值会随着环境的变化而变化。为了让它“纯”起来,我们可以把它包裹在一个函数内部,延迟执行它:
function readLocalStorage(){ return function(){ return window.localStorage; } }
这样 readLocalStorage 就变成了一个真正的纯函数! OvO为机智的程序员鼓掌!
额……好吧……好像确实没什么卵用……我们只是(像大多数拖延症晚期患者那样)把讨厌做的事情暂时搁置了而已。为了能彻底解决这些讨厌的事情,我们需要一个叫 IO 的新的 Functor:
import _ from 'lodash'; var compose = _.flowRight; var IO = function(f) { this.__value = f; } IO.of = x => new IO(_ => x); IO.prototype.map = function(f) { return new IO(compose(f, this.__value)) };
IO 跟前面那几个 Functor 不同的地方在于,它的 __value 是一个函数。它把不纯的操作(比如 IO、网络请求、DOM)包裹到一个函数内,从而延迟这个操作的执行。所以我们认为,IO 包含的是被包裹的操作的返回值。
var io_document = new IO(_ => window.document); io_document.map(function(doc){ return doc.title }); //=> IO(document.title)
注意我们这里虽然感觉上返回了一个实际的值 IO(document.title),但事实上只是一个对象:{ __value: [Function] },它并没有执行,而是简单地把我们想要的操作存了起来,只有当我们在真的需要这个值得时候,IO 才会真的开始求值,这个特性我们称之为『惰性求值』。(培提尔其乌斯:“这是怠惰啊!”)
是的,我们依然需要某种方法让 IO 开始求值,并且把它返回给我们。它可能因为 map 的调用链积累了很多很多不纯的操作,一旦开始求值,就可能会把本来很干净的程序给“弄脏”。但是去直接执行这些“脏”操作不同,我们把这些不纯的操作带来的复杂性和不可维护性推到了 IO 的调用者身上(嗯就是这么不负责任)。
下面我们来做稍微复杂点的事情,编写一个函数,从当前 url 中解析出对应的参数。
import _ from 'lodash'; // 先来几个基础函数: // 字符串 var split = _.curry((char, str) => str.split(char)); // 数组 var first = arr => arr[0]; var last = arr => arr[arr.length - 1]; var filter = _.curry((f, arr) => arr.filter(f)); //注意这里的 x 既可以是数组,也可以是 functor var map = _.curry((f, x) => x.map(f)); // 判断 var eq = _.curry((x, y) => x == y); // 结合 var compose = _.flowRight; var toPairs = compose(map(split('=')), split('&')); // toPairs('a=1&b=2') //=> [['a', '1'], ['b', '2']] var params = compose(toPairs, last, split('?')); // params('http://xxx.com?a=1&b=2') //=> [['a', '1'], ['b', '2']] // 这里会有些难懂=。= 慢慢看 // 1.首先,getParam是一个接受IO(url),返回一个新的接受 key 的函数; // 2.我们先对 url 调用 params 函数,得到类似[['a', '1'], ['b', '2']] // 这样的数组; // 3.然后调用 filter(compose(eq(key), first)),这是一个过滤器,过滤的 // 条件是 compose(eq(key), first) 为真,它的意思就是只留下首项为 key // 的数组; // 4.最后调用 Maybe.of,把它包装起来。 // 5.这一系列的调用是针对 IO 的,所以我们用 map 把这些调用封装起来。 var getParam = url => key => map(compose(Maybe.of, filter(compose(eq(key), first)), params))(url); // 创建充满了洪荒之力的 IO!!! var url = new IO(_ => window.location.href); // 最终的调用函数!!! var findParam = getParam(url); // 上面的代码都是很干净的纯函数,下面我们来对它求值,求值的过程是非纯的。 // 假设现在的 url 是 http://www.php.cn/ // 调用 __value() 来运行它! findParam("a").__value(); //=> Maybe(['a', '1'])
如果你还能坚持看到这里的话,不管看没看懂,已经是勇士了。在这篇文章里,我们先后提到了 Maybe、Either、IO 这三种强大的 Functor,在链式调用、惰性求值、错误捕获、输入输出中都发挥着巨大的作用。事实上 Functor 远不止这三种,但由于篇幅的问题就不再继续介绍了(哼才不告诉你其实是因为我还没看懂其它 Functor 的原理)
但依然有问题困扰着我们:
1. 如何处理嵌套的 Functor 呢?(比如 Maybe(IO(42)))
2. 如何处理一个由非纯的或者异步的操作序列呢?
在这个充满了容器和 Functor 的世界里,我们手上的工具还不够多,函数式编程的学习还远远没有结束,在下一篇文章里会讲到 Monad 这个神奇的东西(然而我也不知道啥时候写下一篇,估计等到实习考核后吧OvO)。
以上就是JavaScript函数式编程(二)的内容,更多相关内容请关注PHP中文网(www.php.cn)!