函数式编程中用于操作数组的方法就像“毒品”一样，它让很多人爱上函数式编程。因为它们真的十分常用而且又超级简单。 .map() 和 .filter()都仅需一个参数，该参数定义操作数组每一个元素的函数即可。reduce()会复杂一些，我之前写过一篇文章介绍为什么人们难以掌握reduce()方法，其中一个原因在于很多入门资料都仅仅用算术作为例子。我写了很多用reduce()来做算术以外的例子。

用reduce()来计算数组的平均值是一个常用的模式。代码看起来非常简单，不过在计算最终结果之前你需要做两个准备工作：

数组的长度
	
数组所有元素之和
这两个事情看起来都很简单，那么计算数组的平均值并不是很难了吧。解法如下：

function average(nums) {
    return nums.reduce((a, b) => a + b) / nums.length;
}
复制代码

确实不是很难，是吧？但是如果数据结构变得复杂了，就没那么简单了。比如，数组里面的元素是对象，你需要先过滤掉某些对象，然后从对象中取出数字。这样的场景让计算平均值变得复杂了一点。

接下来我们处理一个类似的问题(从this Free Code Camp challenge获得灵感)，我们会提供 5 种不同的解法，每一种方法有各自的优点和缺点。这 5 种方法也展示了 JavaScript 的灵活。我希望可以给你在使用reduce的实战中一些灵感。

问题提出

假设我们有一个数组，记录了维多利亚时代常用的口语。接下来我们要找出那些依然现存于 Google Books 中的词汇，并计算他们的平均流行度。数据的格式是这样的:

const victorianSlang = [
    {
        term: "doing the bear",
        found: true,
        popularity: 108
    },
    {
        term: "katterzem",
        found: false,
        popularity: null
    },
    {
        term: "bone shaker",
        found: true,
        popularity: 609
    },
    {
        term: "smothering a parrot",
        found: false,
        popularity: null
    },
    {
        term: "damfino",
        found: true,
        popularity: 232
    },
    {
        term: "rain napper",
        found: false,
        popularity: null
    },
    {
        term: "donkey’s breakfast",
        found: true,
        popularity: 787
    },
    {
        term: "rational costume",
        found: true,
        popularity: 513
    },
    {
        term: "mind the grease",
        found: true,
        popularity: 154
    }
];
复制代码

接下来我们用 5 中不同的方法计算平均流行度值。

1. for 循环

初次尝试，我们不使用reduce()。如果你对数组的常用函数不熟悉，用 for 循环可以让你更好地理解我们要做什么。

let popularitySum = 0;
let itemsFound = 0;
const len = victorianSlang.length;
let item = null;
for (let i = 0; i < len; i++) {
    item = victorianSlang[i];
    if (item.found) {
        popularitySum = item.popularity + popularitySum;
        itemsFound = itemsFound + 1;
    }
}
const averagePopularity = popularitySum / itemsFound;
console.log("Average popularity:", averagePopularity);
复制代码

如果你熟悉 JavaScript，上面的代码理解起来应该很容易：

初始化polularitySum和itemsFound变量。popularitySum记录总的流行度值，itemsFound记录我们已经找到的所有的条目；
	
初始化len和item来帮助我们遍历数组；
	
for 循环每一次增加i的值，直到循环n次；
	
在循环中，我们每次取出当前索引位置的条目vitorianSlang[i]；
	
检查该条目是否在 Google Books 中
	
如果在，获取popularity并累加到popularitySum；
	
并递增itemsFound；
	
最后，用popularitySum除以itemsFound来计算平均值。
代码虽然不是那么简洁，但是顺利完成了任务。使用数组迭代方法可以更加简洁，接下来开始吧…..

2. 简单模式: filter, map 和 sum

我们首先将这个问题拆分成几个子问题：

使用fitler()找到那些在 Google Books 中的条目;
	
使用map()获取流行度；
	
使用reuduce()来计算总的流行度；
	
计算平均值。
下面是实现代码：

// 辅助函数
// ----------------------------------------------------------------------------
function isFound(item) {
    return item.found;
}

function getPopularity(item) {
    return item.popularity;
}

function addScores(runningTotal, popularity) {
    return runningTotal + popularity;
}

// 计算
// ----------------------------------------------------------------------------

// 找出所有isFound为true的条目
const foundSlangTerms = victorianSlang.filter(isFound);

// 从条目中获取流行度值，返回为数组
const popularityScores = foundSlangTerms.map(getPopularity);

// 求和
const scoresTotal = popularityScores.reduce(addScores, 0);

// 计算平均值
const averagePopularity = scoresTotal / popularityScores.length;
console.log("Average popularity:", averagePopularity);
复制代码

注意看addScores函数以及调用reduce()函数的那一行。addScores()接收两个参数，第一个runningTotal，我们把它叫做累加数，它一直记录着累加的总数。每访问数组中的一个条目，我们都会用addScores函数来更新它的值。第二个参数popularity是当前某个元素的值。注意，第一次调用的时候，我们还没有runningTotal的值，所以在调用reduce()的时候，我们给runningTotal初始化。也就是reduce()的第二个参数。

这个版本的代码简洁很多了，也更加的直观。我们不再告诉 JavaScript 引擎如何循环，如何对当前索引的值做操作。我们定义了很多小的辅助函数，并且把它们组合起来完成任务。filter()，map()和reduce()帮我们做了很多工作。上面的实现更加直观地告诉我们这段代码要做什么，而不是底层如何去实现。

3. 简单模式 II: 记录多个累加值

在之前的版本中，我们创建了很多中间变量：foundSlangTerms，popularityScores。接下来，我们给自己设一个挑战，使用链式操作，将所有的函数调用组合起来，不再使用中间变量。注意：popularityScores.length变量需要用其它的方式来获取。我们可以在addScores的累加参数中记录它。

// 辅助函数
// ---------------------------------------------------------------------------------
function isFound(item) {
    return item.found;
}

function getPopularity(item) {
    return item.popularity;
}

// 我们使用一个对象来记录总的流行度和条目的总数
function addScores({ totalPopularity, itemCount }, popularity) {
    return {
        totalPopularity: totalPopularity + popularity,
        itemCount: itemCount + 1
    };
}

// 计算
// ---------------------------------------------------------------------------------

const initialInfo = { totalPopularity: 0, itemCount: 0 };
const popularityInfo = victorianSlang
    .filter(isFound)
    .map(getPopularity)
    .reduce(addScores, initialInfo);

const { totalPopularity, itemCount } = popularityInfo;
const averagePopularity = totalPopularity / itemCount;
console.log("Average popularity:", averagePopularity);
复制代码

我们在reduce函数中使用对象来记录了totalPopularity和itemCount。在addScores中，每次都更新itemCount的计数。

通过filter，map和reduce计算的最终的结果存储在popularityInfo中。你甚至可以继续简化上述代码，移除不必要的中间变量，让最终的计算代码只有一行。

4. point-free 式函数组合

注意: 如果你不熟悉函数式语言或则觉得难以理解，请跳过这部分！

如果你熟悉curry()和compose()，接下来的内容就不难理解。如果你想知道更多，可以看看这篇文章: ‘A Gentle Introduction to Functional JavaScript’. 特别是第三部分 。

我们可以使用compose函数来构建一个完全不带任何变量的代码，这就叫做point-free的方式。不过，我们需要一些帮助函数。

// 辅助函数
// ----------------------------------------------------------------------------
const filter = p => a => a.filter(p);
const map = f => a => a.map(f);
const prop = k => x => x[k];
const reduce = r => i => a => a.reduce(r, i);
const compose = (...fns) => arg => fns.reduceRight((arg, fn) => fn(arg), arg);

// The blackbird combinator.
// See: https://jrsinclair.com/articles/2019/compose-js-functions-multiple-parameters/
const B1 = f => g => h => x => f(g(x))(h(x));

// 计算
// ----------------------------------------------------------------------------

// 求和函数
const sum = reduce((a, i) => a + i)(0);

// 计算数组长度的函数
const length = a => a.length;

// 除法函数
const div = a => b => a / b;

// 我们使用compose()来将函数组合起来
// compose()的参数你可以倒着读，来理解程序的含义
const calcPopularity = compose(
    B1(div)(sum)(length),
    map(prop("popularity")),
    filter(prop("found"))
);

const averagePopularity = calcPopularity(victorianSlang);
console.log("Average popularity:", averagePopularity);
复制代码

我们在compose中做了所有的计算。从后往前看，首先filter(prop('found'))筛选出所有在 Google Books 中的条目，然后通过map(prop('popularity'))获取所有的流行度数值，最后使用 magical blackbird (B1) combinator 来对同一个输入进行sum和length的计算，并求得平均值。

// All the lines below are equivalent:
const avg1 = B1(div)(sum)(length);
const avg2 = arr => div(sum(arr))(length(arr));
const avg3 = arr => sum(arr) / length(arr);
const avg4 = arr => arr.reduce((a, x) => a + x, 0) / arr.length;
复制代码

不要担心看不明白，上面主要是为大家演示有 4 种方式来实现average功能。这就是 JavaScript 的优美之处。

相对来说，本文的内容是有点极客的。虽然笔者之前深度使用函数式语言 Haskell 做过不少研究项目，对函数式颇有理解，但是 point-free 风格的代码，我们是不建议在实际工程中使用的，维护成本会很高。我们Fundebug所有的代码都要求直观易懂，不推崇用一些奇淫技巧来实现。除非某些万不得已的地方，但是一定要把注释写得非常清楚，来降低后期的维护成本。

5. 终极优化: 一次计算出结果

之前所有的解法都可以很好地工作。那些使用reduce()的解法都有一个共同点，它们将大的问题拆解问小的子问题，然后通过不同的方式将它们组合起来。但是也要注意它们对数组遍历了三次，感觉很没有效率。如果一次就可以计算出来，才是最佳的方案。确实可以，不过需要一点数学运算。

为了计算 n 个元素的平均值，我们使用下面的公式：

 



 
 


那么，计算 n+1 个元素的平均值，使用同样的公式（唯一不同的是 n 变成 n+1）：

 



 
 


它等同于:

 



 
 


同样等同于:

 



 
 


做点变换:

 



 
 


结论是，我们可以一直记录当前状态下的所有满足条件的元素的平均值。只要我们知道之前所有元素的平均值和元素的个数。

// 求平均值
function averageScores({ avg, n }, slangTermInfo) {
    if (!slangTermInfo.found) {
        return { avg, n };
    }
    return {
        avg: (slangTermInfo.popularity + n * avg) / (n + 1),
        n: n + 1
    };
}

const initialVals = { avg: 0, n: 0 };
const averagePopularity = victorianSlang.reduce(averageScores, initialVals).avg;
console.log("Average popularity:", averagePopularity);
复制代码

这个方法只需要遍历一次就计算出平均值，缺点是我们做了更多的计算。每一次当元素满足条件，都要做乘法和除法，而不是最后才做一次除法。不过，它使用了更少的内存，因为没有中间的数组变量，我们只是记录了一个仅仅有两个元素的对象。

这样写还有一个缺点，代码一点都不直观，后续维护麻烦。至少一眼看过去不能理解它是做什么的。

所以，到底哪一种方案才是最好的呢？视情形而定。也许你有一个很大的数组要处理，也许你的代码需要在内存很小的硬件上跑。在这些场景下，使用第 5 个方案最佳。如果性能不是问题，那么就算使用最低效的方法也没问题。你需要选择最适合的。

还有一些聪明的朋友会思考：是否可以将问题拆解为子问题，仍然只遍历一次呢？是的，确实有。需要使用 transducer。

 

如果你对编程感兴趣或者想往编程方向发展，可以关注微信公众号【筑梦编程】，大家一起交流讨论！小编也会每天定时更新既有趣又有用的编程知识！

 

不得不说RSI指标真的是一个很神奇的东西，看透了它就像看透了彩票的中奖数字一样，不能说是稳赢吧，但是也八九不离十了，至少不会输得很惨。很多人疑惑，RSI指标究竟是怎样计算的?能够让人如此信服。应该如何分析RSI指标的变化。今天小编就来为大家解答这些问题。大家也可以关注QR技术分析社区，里面也有详解。

　　首先，大家要知道RSI指标的计算公式: N日RSI =N日内收盘涨幅的平均值/(N日内收盘涨幅均值+N日内收盘跌幅均值) ×100。由这个算式就不难理解RSI指标的技术含义，即以向上的力量与向下的力量进行比较，若向上的力量较大，则计算出来的指标上升;若向下的力量较大，则指标下降，由此就可以测算出市场走势的强弱。

　　其实要想准确的分析RSI指标，就要先了解rsi指标的操作方向。RSI值将0到100之间分成了从"极弱"、“弱”"强"到"极强"四个区域。"强"和"弱"以50作为分界线,但"极弱"和"弱"之间以及"强"和"极强"之间的界限则要随着RSI参数的变化而变化。

　　然而不同的rsi指标参数,其区域的划分就不同。一般来说, rsi指标参数越大,分界线离中心线50就越近,离100和0就越远。不过一般都应落在15、30到70、85的区间内。RSI值如果超过50,表明市场进入强市,可以考虑买入,但是如果继续进入"极强"区,就要考虑物极必反,准备卖出了。同理RSI值在50以下也是如此,如果进入了"极弱"区,则表示超卖,应该伺机买入。这里建议大家关注QR社区，里面有很多经验之谈。

　　所以为什么说RSI指标很神奇呢?正是因为通过 RSI指标能够较清楚地看出市场何时处于超买状态和超卖状态，从而较好地把握买卖时机。不仅如此，RSI指标对于个股的波动反应很及时，特别适用于短线操作。并且相对于其它指标的滞后性，RSI指标往往能先于K线图反应短期走势。

　　关于RSI指标的理论有很多很多，只要你肯用心，铁杵也能磨成针。所以希望热爱股票的朋友一定要好好研究一下rsi指标，小编在这里只是讲了一些皮毛，需要大家去深入了解才能完全掌握RSI指标的使用。最后推荐大家看一下QMACD知识，对了解RSI很有帮助。

自动筛选的技巧（2）-找到低于平均数的记录
设计要点：数据、自动筛选，排序
 
阿金：用这个方法，还可以筛选出，“数量”排名前10%的的记录。
秀秀：嗯，其实很强大啊！
阿金：再问你个问题，怎样找到低于平均数的记录？
秀秀：嗯，一样的啊！！自动筛选也有这个功能！
阿金：关键是，它不用计算平均值也可以。
秀秀：哈哈哈，可以偷懒啊！
阿金：哈哈哈，非常适合你！
秀秀：难道你不愿意用？！

怎样在Excel表格中求平均数?
在excel中怎样自动生成各班各科的平均成绩
可以调用Excel函数库的函实现。
步骤如下：
1.  在单元格内点击上公式-平均值”。
2.  点击需要参与计算的单元格数据，符号用键盘输入，最后回车即可。
百度百科-Excel函数
excel中 如何将大量的数据，自动均等的分成几个独...
有一个简单法不知道够不够便捷   使用筛选
在所需的数据项目前插入一列数据入=row()
然后使用筛选一插入的列为目标 筛选 总数/14 的值
然后分别复制到其他表格  不过需要筛选14次
可以考虑做成宏
比如下面的例子  录制一个简单宏 将Rows("1:9").Select中的 9  改为 总数/14  的值我只是做个例子
Sub Macro2()
Rows("1:9").Select
Selection.Cut
End Sub
然后去新表格按ctrl v  选中的数据行黏贴过去  14次
EXCEL数据分析图怎么插入平均数值线
1、首先打开excel，在表格中可以看到单元格并没有平布，选中需要设置的单区域。
2、然后点击工具栏中的“行和列”选项，在其下拉菜单中点击“行高”选项。
3、即可打开“行高”对话框，在其中输入需要的数值，点击确定按钮。
4、再点击“列宽”选项，在打开的列宽对话框中输入需要的数值，点击确定。
5、即可将选中的单元格区域更改为行高和列宽都固定的样式了。
用Excel怎么才能将组数据平均分配给几个人
A1:A48、B1:B48分别为姓名和分数，并对分数行了升序或降序。
在C1中输入或复制粘贴下列公
=MOD(ROW(A4),4) 1
或
=MOD(ROW(A1)-1,4) 1
下拉填充或双击C1的填充柄
选择C1:C48，复制，粘贴数值。
将C列进行升序或降序排列。
※●★◆■▲上面的处理方法，还是有问题，第1组和第12组分别是最强或最弱的。
C1:C8应该按1、2、3、4、4、3、2、1输入数值，复制后再连续粘贴5次，这样分组后各组的平均分比上述方法更接近。