媒介
lodash受欢迎的一个缘由，是其优秀的盘算机能。而其机能能有这么凸起的表现，很大部份就来源于其运用的算法——惰性求值。
本文将报告lodash源码中，惰性求值的道理和完成。
一、惰性求值的道理剖析
惰性求值（Lazy Evaluation），又译为惰性盘算、懒散求值，也称为传需求挪用（call-by-need），是盘算机编程中的一个观点，它的目标是要
最小化盘算秘密做的事情。惰性求值中的参数直到须要时才会举行盘算。这类顺序实际上是
从末端最先反向实行的。它会推断本身须要返回什么，并继承向后实行来确定要如许做须要哪些值。
以下是How to Speed Up Lo-Dash ×100? Introducing Lazy Evaluation.（怎样提拔Lo-Dash百倍算力？惰性盘算的简介）文中的示例，抽象地展现惰性求值。
function priceLt(x) {
return function(item) { return item.price < x; };
}
var gems = [
{ name: 'Sunstone', price: 4 },
{ name: 'Amethyst', price: 15 },
{ name: 'Prehnite', price: 20},
{ name: 'Sugilite', price: 7 },
{ name: 'Diopside', price: 3 },
{ name: 'Feldspar', price: 13 },
{ name: 'Dioptase', price: 2 },
{ name: 'Sapphire', price: 20 }
];
var chosen = _(gems).filter(priceLt(10)).take(3).value();顺序的目标，是对数据集gems举行挑选，选出3个price小于10的数据。
1.1 平常的做法
假如抛开lodash这个东西库，让你用一般的体式格局完成var chosen = _(gems).filter(priceLt(10)).take(3);那末，能够用以下体式格局： _(gems)拿到数据集，缓存起来。
再实行filter要领，遍历gems数组（长度为10），掏出相符前提的数据：
[
{ name: 'Sunstone', price: 4 },
{ name: 'Sugilite', price: 7 },
{ name: 'Diopside', price: 3 },
{ name: 'Dioptase', price: 2 }
]然后，实行take要领，提取前3个数据。
[
{ name: 'Sunstone', price: 4 },
{ name: 'Sugilite', price: 7 },
{ name: 'Diopside', price: 3 }
]统共遍历的次数为：10+3。
实行的示例图以下：
1.2 惰性求值做法
一般的做法存在一个题目：每一个要领各做各的事，没有谐和起来浪费了许多资本。
假如能先把要做的事，用小本本记下来😎，然后比及真正要出数据时，再用起码的次数到达目标，岂不是更好。
惰性盘算就是这么做的。
以下是完成的思绪：
-
_(gems)拿到数据集，缓存起来 - 碰到
filter要领，先记下来 - 碰到
take要领，先记下来 - 碰到
value要领，申明机遇到了 - 把小本本拿出来，看下请求：要掏出3个数，price<10
- 运用
filter要领里的推断要领priceLt对数据举行逐一判决
[
{ name: 'Sunstone', price: 4 }, => priceLt判决 => 相符请求，经由过程 => 拿到1个
{ name: 'Amethyst', price: 15 }, => priceLt判决 => 不相符请求
{ name: 'Prehnite', price: 20}, => priceLt判决 => 不相符请求
{ name: 'Sugilite', price: 7 }, => priceLt判决 => 相符请求，经由过程 => 拿到2个
{ name: 'Diopside', price: 3 }, => priceLt判决 => 相符请求，经由过程 => 拿到3个 => 够了，收工！
{ name: 'Feldspar', price: 13 },
{ name: 'Dioptase', price: 2 },
{ name: 'Sapphire', price: 20 }
]如上所示，一共只实行了5次，就把效果拿到。
实行的示例图以下：
1.3 小结
从上面的例子能够获得惰性盘算的特性：
- 耽误盘算，把要做的盘算先缓存，不实行
- 数据管道，逐一数据经由过程“判决”要领，在这个相似安检的过程当中，举行过关的操纵，末了只留下相符请求的数据
- 触发机遇，要领缓存，那末就须要一个要领来触发实行。lodash就是运用
value要领，关照真正最先盘算
二、惰性求值的完成
依据上述的特性，我将lodash的惰性求值完成举行抽离为以下几个部份：
2.1 完成耽误盘算的缓存
完成_(gems)。我这里为了语义明白，采纳lazy(gems)替代。
var MAX_ARRAY_LENGTH = 4294967295; // 最大的数组长度
// 缓存数据构造体
function LazyWrapper(value){
this.__wrapped__ = value;
this.__iteratees__ = [];
this.__takeCount__ = MAX_ARRAY_LENGTH;
}
// 惰性求值的进口
function lazy(value){
return new LazyWrapper(value);
}-
this.__wrapped__缓存数据 -
this.__iteratees__缓存数据管道中举行“判决”的要领 -
this.__takeCount__纪录须要拿的相符请求的数据集个数
如许，一个基础的构造就完成了。
2.2 完成filter要领
var LAZY_FILTER_FLAG = 1; // filter要领的标记
// 依据 挑选要领iteratee 挑选数据
function filter(iteratee){
this.__iteratees__.push({
'iteratee': iteratee,
'type': LAZY_FILTER_FLAG
});
return this;
}
// 绑定要领到原型链上
LazyWrapper.prototype.filter = filter;filter要领，将判决要领iteratee缓存起来。这里有一个主要的点，就是须要纪录iteratee的范例type。
因为在lodash中,另有map等挑选数据的要领，也是会传入一个判决要领iteratee。因为filter要领和map要领挑选体式格局差别，所以要用type举行标记。
这里另有一个技能：
(function(){
// 私有要领
function filter(iteratee){
/* code */
}
// 绑定要领到原型链上
LazyWrapper.prototype.filter = filter;
})();原型上的要领，先用一般的函数声明，然后再绑定到原型上。假如东西内部须要运用filter，则运用声明好的私有要领。
如许的优点是，外部假如转变LazyWrapper.prototype.filter，对东西内部，是没有任何影响的。
2.3 完成take要领
// 截取n个数据
function take(n){
this.__takeCount__ = n;
return this;
};
LazyWrapper.prototype.take = take;2.4 完成value要领
// 惰性求值
function lazyValue(){
var array = this.__wrapped__;
var length = array.length;
var resIndex = 0;
var takeCount = this.__takeCount__;
var iteratees = this.__iteratees__;
var iterLength = iteratees.length;
var index = -1;
var dir = 1;
var result = [];
// 标签语句
outer:
while(length-- && resIndex < takeCount){
// 外层轮回待处置惩罚的数组
index += dir;
var iterIndex = -1;
var value = array[index];
while(++iterIndex < iterLength){
// 内层轮回处置惩罚链上的要领
var data = iteratees[iterIndex];
var iteratee = data.iteratee;
var type = data.type;
var computed = iteratee(value);
// 处置惩罚数据不相符请求的状况
if(!computed){
if(type == LAZY_FILTER_FLAG){
continue outer;
}else{
break outer;
}
}
}
// 经由内层轮回，相符请求的数据
result[resIndex++] = value;
}
return result;
}
LazyWrapper.prototype.value = lazyValue;
这里的一个重点就是：标签语句
outer:
while(length-- && resIndex < takeCount){
// 外层轮回待处置惩罚的数组
index += dir;
var iterIndex = -1;
var value = array[index];
while(++iterIndex < iterLength){
// 内层轮回处置惩罚链上的要领
var data = iteratees[iterIndex];
var iteratee = data.iteratee;
var type = data.type;
var computed = iteratee(value);
// 处置惩罚数据不相符请求的状况
if(!computed){
if(type == LAZY_FILTER_FLAG){
continue outer;
}else{
break outer;
}
}
}
// 经由内层轮回，相符请求的数据
result[resIndex++] = value;
}
当前要领的数据管道完成，实在就是内层的while轮回。经由过程掏出缓存在iteratees中的判决要领掏出，对当前数据value举行判决。
假如判决效果是不相符，也即为false。那末这个时刻，就没必要用后续的判决要领举行推断了。而是应当跳出当前轮回。
而假如用break跳出内层轮回后，外层轮回中的result[resIndex++] = value;照样会被实行，这是我们不愿望看到的。
应当一次性跳出表里两层轮回，而且继承外层轮回，才是准确的。
标签语句，恰好能够满足这个请求。
2.5 小检测
var testArr = [1, 19, 30, 2, 12, 5, 28, 4];
lazy(testArr)
.filter(function(x){
console.log('check x='+x);
return x < 10
})
.take(2)
.value();
// 输出以下：
check x=1
check x=19
check x=30
check x=2
// 获得效果： [1, 2]2.6 小结
全部惰性求值的完成，重点照样在数据管道这块。以及，标签语句在这里的妙用。实在完成的体式格局，不只当前这类。然则，要点照样前面讲到的三个。控制精华，变通就很轻易了。
结语
惰性求值，是我在浏览lodash源码中，发明的最大闪光点。
当初对惰性求值不甚明白，想看下javascript的完成，但网上也只找到上文提到的一篇文献。
那剩下的挑选，就是对lodash举行剖离剖析。也因为这，才有本文的降生。
愿望这篇文章能对你有所协助。假如能够的话，给个star :)
末了，附上本文完成的简易版lazy.js完全源码：
https://github.com/wall-wxk/blogDemo/blob/master/lodash/lazy.js
喜欢我文章的朋侪，能够经由过程以下体式格局关注我：
- 「star」 或 「watch」 我的GitHub blog
- RSS定阅我的个人博客：王先生的基地
