JavaScript 関数プログラミング (2)

前の記事で、純粋関数の概念について説明しました。いわゆる純粋関数とは、同じ入力に対して、目に見える副作用がなく、状態に依存せずに常に同じ出力が得られることを意味します。外部環境の(怠け者だったのでコピーしました)。

しかし、実際のプログラミング、特にフロントエンドプログラミングの分野では、「外部環境に依存しない」という条件は不可能であり、私たちはDOMやAJAXのような常に状態が変化するものに常にさらされています。 。したがって、汚れ仕事を行うには、より強力なテクノロジーを使用する必要があります。

1. コンテナ、ファンクター

jQuery に精通している場合、$(...) によって返されるオブジェクトはネイティブ DOM オブジェクトではなく、ネイティブ オブジェクトの一種のカプセル化であることを覚えておく必要があります。

var foo = $('#foo'); 
foo == document.getElementById('foo'); 
//=> false

foo[0] == document.getElementById('foo'); 
//=> true

これはある意味「コンテナ」です（ただし機能しません）。

次のクラスでは、コンテナーが関数型プログラミングの通常の変数、オブジェクト、関数に非常に強力なコートを提供し、トニー・スタークの鋼鉄コート、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')

そうです!たった 7 行のコードで、最初の Functor であるクールな「Chained Call」 を実装しました。

Functor は、マップを実装し、いくつかの特定のルールに従うコンテナー タイプです。

つまり、コンテナによってラップされた値に通常の関数を適用したい場合は、まず Functor と呼ばれるデータ型を定義する必要があります。このデータ型では、その使用方法を定義する必要があります。 mapを適用するこの普通の関数。

ものをコンテナに入れて、コンテナの外の関数用に 1 つのインターフェイス map だけを残す これを行う利点は何ですか?

本質的に、Functor は関数呼び出しの抽象化であり、コンテナーにそれ自体で関数を呼び出す機能を与えます。関数を マップするとき、コンテナが独自に関数を実行できるようにします。これにより、コンテナは関数をいつ、どこで、どのように操作するかを自由に選択できるようになります。そのため、遅延評価、エラー処理、非同期呼び出しが非常に優れています。 、などの特徴があります。

たとえば、null 値をチェックする機能を 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)

これらのコードを読んだ後、私は次のように感じます。 chain-like 呼び出すときにいつも .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)

2. エラー処理、どちらか

これで、コンテナーが実行できることは少なすぎますが、単純なエラー処理も実行できます。いいえ、今はエラーのみを処理できます。このように:

try{
    doSomething();
}catch(e){
    // 错误处理
}

try/catch/throw は、外部から関数を引き継ぎ、この関数が失敗したときに戻り値を破棄するため、「純粋」ではありません。これは予期される機能的な動作ではありません。

Promise に精通している場合は、Promise が catch を呼び出してエラーを一元的に処理できることを覚えておく必要があります。

doSomething()
    .then(async1)
    .then(async2)
    .catch(e => console.log(e));

関数型プログラミングの場合、同じ操作を実行することもできます。正しく実行されれば、正しい結果が返されます。 ; if エラーが発生した場合は、エラーを説明する結果が返されます。この概念はHaskellではEitherクラスと呼ばれ、LeftとRightはその2つのサブクラスです。 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 は、呼び出しチェーン内の任意のリンクでエラーを起こして、すぐに呼び出しチェーンの最後に戻ることができるため、エラー処理に大きな利便性をもたらします。 トライ/キャッチを何層にも重ねていきます。

Left 和 Right 是 Either 类的两个子类，事实上 Either 并不只是用来做错误处理的，它表示了逻辑或，范畴学里的 coproduct。但这些超出了我们的讨论范围。

三、IO

下面我们的程序要走出象牙塔，去接触外面“肮脏”的世界了，在这个世界里，很多事情都是有副作用的或者依赖于外部环境的，比如下面这样：

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）！