【译】怎样百倍加快LoDash？引入惰性盘算

原文：How to Speed Up Lo-Dash ×100? Introducing Lazy Evaluation.
作者: Filip Zawada

译文：怎样百倍加快 Lo-Dash？引入惰性盘算
译者：justjavac

我一向认为像 Lo-Dash 如许的库已不能再快了，毕竟它们已充足快了。
Lo-Dash 险些完整夹杂了种种 Javascript 奇技淫巧（YouTube）来压榨出最好的机能。

惰性盘算

但好像我错了 &＃8211; 实在 Lo-Dash 能够运转的更快。
你须要做的是，住手思索那些纤细的优化，并最先找出越发实用的算法。
比方，在一个典范的轮回中，我们每每倾向于去优化单次迭代的时候：

var len = getLength();
for(var i = 0; i operation(); // <- 10毫秒 - 怎样优化到9毫秒?!
}

代码申明：取得数组的长度，然后反复实行 N 遍 operation() 函数。译注 by @justjavac

然则，这（优化 operation() 实行时候）每每很难，而且对机能提拔也异常有限。
相反，在某些情况下，我们能够优化 getLength() 函数。
它返回的数字越小，则每一个 10 毫秒轮回的实行次数就越少。

这就是 Lo-Dash 运用惰性盘算的头脑。
这是削减周期数，而不是削减每一个周期的实行时候。
让我们看看下面的例子：

function priceLt(x) {
return function(item) { return item.price }
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 保留了 8 个对象，名字和价钱。priceLt(x) 函数返回价钱低于 x 的一切元素。译注 by @justjavac

我们把价钱低于 10 美圆的前 3 个 gems 找出来。
通例 Lo-Dash 要领（严厉盘算）是过滤一切 8 个 gems，然后返回过滤效果的前 3 个。

不难看出来，这类算法是不明智的。
它处置惩罚了一切的 8 个元素，而实际上我们只须要读取个中的 5 个元素就可以取得我们想要的效果。
与此相反，运用惰性盘算算法，只须要处置惩罚能取得效果的起码数目就可以够了。
如图所示：

我们易如反掌就取得了 37.5％ 的机能提拔。
然则这还不是悉数，实在很轻易找到能取得 1000 倍以上机能提拔的例子。
让我们一同来看看：

// 99,999 张照片
var phOneNumbers= [5554445555, 1424445656, 5554443333, … ×99,999];
// 返回包括 "55" 的照片
function contains55(str) {
return str.contains("55");
};
// 取 100 张包括 "55" 的照片
var r = _(phoneNumbers).map(String).filter(contains55).take(100);

在这个例子中，map 和 filter 用来处置惩罚 99,999 个元素。
不过我们只须要它的一个子集就可以够取得想要的效果了，比方 10,000 个，
机能提拔也是异常大的（基准测试）：

Pipelining

惰性盘算带来了另一个优点，我称之为 &＃8220;Pipelining&＃8221;。
它能够防止链式要领实行时期建立中心数组。
取而代之，我们在单个元素上实行一切操纵。
所以，下面的代码：

var result = _(source).map(func1).map(func2).map(func3).value();

将大抵翻译为以下的通例 Lo-Dash（严厉盘算）

var result = [], temp1 = [], temp2 = [], temp3 = [];
for(var i = 0; i temp1[i] = func1(source[i]);
}
for(i = 0; i temp2[i] = func2(temp1[i]);
}
for(i = 0; i temp3[i] = func3(temp2[i]);
}
result = temp3;

假如我们运用惰性盘算，它会像下面如许实行：

var result = [];
for(var i = 0; i result[i] = func3(func2(func1(source[i])));
}

不运用暂时数组能够给我们带来异常明显的机能提拔，特别是当源数组异常大时，内存接见是高贵的资本。

耽误实行

和惰性盘算一同运用的是耽误实行。
当你建立一个链，我们并不马上盘算它的值，直到 .value() 被显式或许隐式地挪用。
这类要领有助于先预备一个查询，随后我们运用最新的数据来实行它。

var wallet = _(assets).filter(ownedBy('me'))
.pluck('value')
.reduce(sum);
$json.get("/new/assets").success(function(data) {
assets.push.apply(assets, data); // 更新我的资金
wallet.value(); // 返回我钱包的最新的总额
});

在某些情况下，如许做也能够加快实行时候。我们能够在前期建立庞杂的查询，然后当时机成熟时再实行它。

Wrap up

懒散盘算并非行业里的新理念。它已包括在了很多库内里，比方 LINQ、Lazy.js 等等。我置信 Lo-Dash 和这些库最主要的区别是，你能够在一个更新的、更壮大的引擎内里运用原有的 Underscore API。不须要学习新的库，不须要修正代码，只是简朴晋级。

然则，纵然你不盘算运用 Lo-Dash，我愿望这篇文章启发了你。
如今，当你发明你的应用程序存在机能瓶颈，不要仅仅是去 jsperf.com 以 try/fail 作风优化它。
而是去喝杯咖啡，并最先斟酌算法。
最主要的是创意，但优越的数学背景会让你瓮中之鳖（book）。祝你好运！