站在C#和JS的角度细谈函数式编程与闭包

1.函数式编程是什么？

摘自百度的说法是。函数式编程是种编程典范，它将电脑运算视为函数的计算。函数编程语言最重要的基础是 λ 演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。和过程化编程相比，函数式编程里，函数的计算可随时调用。

举个例子。平时如果我们要对集合中的元素进行筛选的话，每次都要写循环，都写这么一大堆代码，麻烦不？

　　　　 static void Main(string[] args)
{
List<int> list = new List<int>() { 1, 2, 3, 4, 5 };
List<int> result1 = new List<int>();
List<int> result2 = new List<int>();
foreach (var item in list)
{
if (item % 2 == 0)
result1.Add(item);
}

foreach (var item in list)
{
if (item > 3)
result2.Add(item);
}
}

有没办法构造一个通用的方法？这个方法内部去循环我们要筛选的数组。这样调用方只要指定筛选条件即可。

我们仔细观察下，归纳下它们的共同只处。

1.需要循环

这个很简单，想到循环，我们就应该想到IEnumable

2.筛选条件

我们能不能把筛选元素的这个条件看成一个函数？如

public bool Function(object 当前元素){

　　　　//条件
　　　　if(当前元素.xx属性>2)//满足条件
return true;

else
　　　　　　　　return false;
}

看到这个方法是不是会想到Func<object,bool>？

3.返回结果

这个可以看成把满足条件的元素全部加入到一个集合中，返回回去

知道了这3个条件后，我们大概能构造一个这样的东西

static void Main(string[] args)
{
List<int> list = new List<int>() { 1, 2, 3, 4, 5 };
var result = MyWhere(list, x => x % 2 == 0);
}
public static IEnumerable<TInput> MyWhere<TInput>(IEnumerable<TInput> inputlist, Func<TInput, bool> func)
{
foreach (TInput item in inputlist)
{
if (func(item))
yield return item;
}
yield break;
}

但我们每次都要传入一个list，感觉好麻烦，是不是能改造成扩展方法？

class Program
{
static void Main(string[] args)
{
List<int> list = new List<int>() { 1, 2, 3, 4, 5 };
var result = list.MyWhere(x => x % 2 == 0);
}
}

public static class MyLinq
{
public static IEnumerable<TInput> MyWhere<TInput>(this IEnumerable<TInput> inputlist, Func<TInput, bool> func)
{
foreach (TInput item in inputlist)
{
if (func(item))
yield return item;
}
yield break;
}
}

现在是不是爽多了？

我归纳的函数式编程的核心思想是将相同逻辑的部分封装起来。不同逻辑的部分将它封装成一个函数，由调用方来指定这个函数的逻辑

很多人想问了，JAVA为什么没有类似LINQ这类的扩展方法。。

因为JAVA没有委托这东西，它的思想是完全的面向接口。当然你也可以弄个类似LINQ这类的方法，但用起来会非常变态。首先你要实现定义的某个接口，然后再实现接口里定义的Where方法，这个方法里写你的实现（筛选）逻辑。。这谁会用啊？

如果C#没有匿名委托或lambda。。类似LINQ这类的扩展方法用起来也会很不友好，可以说是变态。

你想想 x=>x.age>5 一句话能搞定，硬要你写个方法。。public bool Find(对象 x){ return x.age>5; }

2.LINQ能移植到JS上吗？

答案是肯定的。可以！函数式编程只是一种思想，只要语言支持匿名方法，玩起来都很爽。

JS是支持匿名函数的，而且是弱类型，所以玩起来非常爽了。

一开始我就在想，有没linq to javascript这东西。结果一搜，果然有=。=

　　　　(function () {
LINQ = function (data) {
if (!(data instanceof Array) && !(data instanceof $.fn.init))
throw "只支持数组或JQUERY对象";
this.data = data;
};
LINQ.prototype = {
Where: function (func) {
var result = new Array();
for (var i = 0; i < this.data.length; i++) {
var item = this.data[i];
if (func(item))
result.push(item);
}
this.data = result;
return this;
},
Foreach: function (func) {
for (var i = 0; i < this.data.length; i++) {
var item = this.data[i];
func(item);
}
}
}
})();

$(function () {
var linq = new LINQ([1, 2, 3, 4, 5, 6]);
var result = linq.Where(function (item) {
return item >= 4;
}).Foreach(function (item) {
console.log(item);
});
})

3.JS的闭包是什么？C#有闭包这个概念吗？

摘自百度的说法是。闭包是可以包含自由（未绑定到特定对象）变量的代码块；这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。

这样说大家可能不明白，下面来看看代码。

场景1

javscript

　   $(function () {
var array = [];
for (var i = 0; i < 10; i++) {
array.push(function () {
console.log(i);
});
}
array.forEach(function (item) {
item();
});
})

C#

　　　　　　List<Action> list = new List<Action>();
for (int i = 0; i < 10; i++)
{
list.Add(() =>
{
Console.WriteLine(i);
});
}
list.ForEach(x => x());

我们函数体内部对函数体外部的变量i产生了依赖。当我们调用Console.WriteLine(i)时，i已经是9了。而且9个委托中依赖的都是同1个实例i。所以打印出来的全部是10。

如果想输出1,2,3,4,5....该怎么改？其实很简单。

场景2

javascript

　　$(function () {
var array = [];
for (var i = 0; i < 10; i++) {
var func = function (item) {
array.push(function () {
console.log(item);
});
};
func(i);
}
array.forEach(function (item) {
item();
});
})

C#

List<Action> list = new List<Action>();
for (int i = 0; i < 10; i++)
{
Action<int> temp = (val) =>
{
list.Add(() =>
{
Console.WriteLine(val);
});
};
temp(i);
}
list.ForEach(x => x());

其实当我们执行temp函数的时候。val已经对i进行拷贝了，val跟i已经没半毛钱关系了(因为C#对于值类型的拷贝是深度拷贝（deep coln，引用类型是拷贝引用），val是一个完全新的实例。所以输出的结果可想而知了。1,2,3,4,5....9。如果觉得难理解可以看下面这段。

　　　　 static List<Action> list = new List<Action>();
static unsafe void Main(string[] args)
{
for (int i = 0; i < 10; i++)
{
Show(i);
}
list.ForEach(x => x());
}
public static unsafe void Show(int val)
{

list.Add(() =>
{
Console.WriteLine(val);
});
}

2段代码是等效的。只不过这里把匿名方法换成了有方法名的具体方法。这样看应该就很好理解了吧。

场景3

上面2种情况下，JS和C#执行后的结果完全一样。但是请看下面这种情况。

javascript

　　　　$(function () {
var array = [];
for (var i = 0; i < 10; i++) {
var temp = i;
array.push(function () {
console.log(temp);
});
}
array.forEach(function (item) {
item();
});
})

C#

　　　　　　List<Action> list = new List<Action>();
for (int i = 0; i < 10; i++)
{
var temp = i;
list.Add(() =>
{
Console.WriteLine(temp);
});
}
list.ForEach((x) => x());

C#理所当然的输出1,2,3,4,5,6...9 为什么？上面说过值类型拷贝是深度拷贝。所以这里会有9个temp实例。而Console.WriteLine(temp)里的temp分别依赖这9个实例的。

再看看JS。执行后，神奇的事情发生了。全部是9。当初我心里很纠结，我实在是想不明白为什么。

后来终于找到答案了。因为JS在函数里面没有代码块作用域（原谅我JS真的很菜）。temp表面上是放在for里面，其实是放在for外面。好吧，心里舒坦多了。如果大家还是不明白，请看下面代码。

　　　　static unsafe void Main(string[] args)
{
List<Action> list = new List<Action>();
var temp = 0;
for (int i = 0; i < 10; i++)
{
temp = i;
list.Add(() =>
{
Console.WriteLine(temp);
});
}
list.ForEach((x) => x());
}

我们list里的所有委托中的Console.WriteLine(temp)依赖的都是同一个temp实例。

如果还是不懂。。。。请再看下面这2段代码

　　　　 public class student
{
public string name { get; set; }
}

static unsafe void Main(string[] args)
{
List<Action> list = new List<Action>();
student stud = null;
for (int i = 0; i < 10; i++)
{
stud = new student()
{
name = "学生" + i
};
list.Add(() =>
{
Console.WriteLine(stud.name);
});
}
list.ForEach((x) => x());
}

执行结果

public class student
{
public string name { get; set; }
}

static unsafe void Main(string[] args)
{
List<Action> list = new List<Action>();
for (int i = 0; i < 10; i++)
{
student stud = new student()
{
name = "学生" + i
};
list.Add(() =>
{
Console.WriteLine(stud.name);
});
}
list.ForEach((x) => x());
}

执行结果



首先最重要的是要理解好C#的值类型和引用类型的区别。

闭包跟匿名函数跟函数式编程之间有着细微关系。如果不好好理解，坑的只是自己。其实语言之间都是大同小异。