如何用 JavaScript 實現一個數組惰性求值庫
在編程語言理論中，惰性求值（英語：Lazy Evaluation），又譯為惰性計算、懶惰求值，也稱為傳需求調用（call-by-need），是一個計算機編程中的一個概念，它的目的是要最小化計算機要做的工作。它有兩個相關而又有區別的含意，可以表示為“延遲求值”和“最小化求值”，除可以得到性能的提升外，惰性計算的最重要的好處是它可以構造一個無限的數據類型。
看到函數式語言里面的惰性求值，想自己用 JavaScript 寫一個最簡實現，加深對惰性求值了解。用了兩種方法，都不到 80 行實現了基本的數組的惰性求值。
怎么實現
惰性求值每次求值的時候并不是返回數值，而是返回一個包含計算參數的求值函數，每次到了要使用值得時候，才會進行計算。
當有多個惰性操作的時候，構成一個求值函數鏈，每次求值的時候，每個求值函數都向上一個求值函數求值，返回一個值。最后當計算函數終止的時候，返回一個終止值。 
當有多個惰性操作的時候，構成一個求值函數鏈，每次求值的時候，每個求值函數都向上一個求值函數求值，返回一個值。最后當計算函數終止的時候，返回一個終止值。 
具體實現
-
判斷求值函數終止
每次求值函數都會返回各種數據，所以得使用一個獨一無二的值來作為判斷流是否完成的標志。剛好 Symbol() 可以創建一個新的 symbol ，它的值與其它任何值皆不相等。
const over = Symbol();
const isOver = function (_over) {
return _over === over;
}
-
生成函數 range
range 函數接受一個起始和終止參數，返回一個求值函數，運行求值函數返回一個值，終止的時候返回終止值。
const range = function (from, to) {
let i = from;
return function () {
if (i < to) {
i++
console.log('range\t', i);
return i
}
return over;
}
}
-
轉換函數 map
接受一個求值函數和處理函數，獲取求值函數 flow 中的數據，對數據進行處理，返回一個流。
const map = function (flow, transform) {
return function () {
const data = flow();
console.log('map\t', data);
return isOver(data) ? data : transform(data);
}
}
-
過濾函數 filter
接受一個求值函數，對求值函數 flow 中數據進行過濾，找到符合的數據并且返回。
const filter = function (flow, condition) {
return function () {
while(true) {
const data = flow();
if (isOver(data)) {
return data;
}
if(condition(data)) {
console.log('filter\t', data);
return data;
}
}
}
}
-
中斷函數 stop
接受一個求值函數，當達到某個條件時中斷，可以用閉包函數加上 stop 函數接著實現一個 take 函數。
const stop = function (flow, condition) {
let _stop = false;
return function () {
if (_stop) return over;
const data = flow();
if (isOver(data)) {
return data;
}
_stop = condition(data);
return data;
}
}
const take = function(flow, num) {
let i = 0;
return stop(flow, (data) => {
return ++i >= num;
});
}
-
收集函數 join
因為返回的都是一個函數，最后得使用一個 join 函數來收集所有的值并且返回一個數組。
const join = function (flow) {
const array = [];
while(true) {
const data = flow();
if (isOver(data)) {
break;
}
array.push(data);
}
return array;
}
測試：
const nums = join(take(filter(map(range(0, 20), n => n * 10), n => n % 3 === 0), 2));
console.log(nums);
/* 輸出
range 1
map 1
range 2
map 2
range 3
map 3
filter 30
range 4
map 4
range 5
map 5
range 6
map 6
filter 60
[ 30, 60 ]
*/
更優雅的實現
上面使用 函數 + 閉包 實現了惰性求值，但是還是不夠優雅，絕大部分代碼都放到迭代和判斷求值是否完成上面去了。其實 es6 中還有更好方法來實現惰性求值，就是使用 generator，generator 已經幫我們解決了迭代和判斷流是否完成，我們就可以專注于邏輯，寫出更簡潔易懂結構清晰的代碼。
const range = function* (from, to) {
for(let i = from; i < to; i++) {
console.log('range\t', i);
yield i;
}
}
const map = function* (flow, transform) {
for(const data of flow) {
console.log('map\t', data);
yield(transform(data));
}
}
const filter = function* (flow, condition) {
for(const data of flow) {
console.log('filter\t', data);
if (condition(data)) {
yield data;
}
}
}
const stop = function*(flow, condition) {
for(const data of flow) {
yield data;
if (condition(data)) {
break;
}
}
}
const take = function (flow, number) {
let count = 0;
const _filter = function (data) {
count ++
return count >= number;
}
return stop(flow, _filter);
}
還得加上鏈式調用才算是完成了。
class _Lazy{
constructor() {
this.iterator = null;
}
range(...args) {
this.iterator = range(...args);
return this;
}
map(...args) {
this.iterator = map(this.iterator, ...args);
return this;
}
filter(...args) {
this.iterator = filter(this.iterator, ...args);
return this;
}
take(...args) {
this.iterator = take(this.iterator, ...args);
return this;
}
[Symbol.iterator]() {
return this.iterator;
}
}
function lazy () {
return new _Lazy();
}
最后再測試一下：
const nums = lazy().range(0, 100).map(n => n * 10).filter(n => n % 3 === 0).take(2);
for(let n of nums) {
console.log('num:\t', n, '\n');
}
/* 輸出
range 0
map 0
filter 0
num: 0
range 1
map 1
filter 10
range 2
map 2
filter 20
range 3
map 3
filter 30
num: 30
*/
好了，大功告成。
總結
這樣我們就完成了一個最簡的數組惰性求值的庫，這里只是簡單實現了惰性求值，要放到工程中還需要添加很多細節。因為代碼不過 80 行，可以很清楚的了解惰性求值原理，還能加深對生成器的理解。
來自：https://zhuanlan.zhihu.com/p/26535479