函数式编程已经存在了60多年，但只有像Google这样的改变游戏规则的企业才会依赖函数式编程，普通程序员对此几乎一无所知。

这种情况很快就要被改变了。像Java或Python这样的语言已经开始越来越多地开始采用函数编程，但是像Haskell这样的新语言已经完全融入了函数式编程。

简单来说，函数式编程就是为不可变变量构建函数。相反，面向对象的编程是要具有一组相对固定的函数，而我们主要是在修改或添加新变量。

函数式编程具有非常适合诸如数据分析和机器学习之类的需求任务的特性。但是这并不意味着我们应该告别面向对象编程，转而完全使用函数式编程。我们需要了解其中的基本原理，这样我们就能在适当的时候使用它们。

一切都是为了消除副作用

要了解函数式编程，我们需要首先了解函数。这听起来可能很无聊，但总而言之，它很有见地。

简单地说，函数是将输入转换为输出的东西。只是事情并没有那么简单。思考一下，在Python中的下面这个函数的意义：

def square(x):
    return x*x

这个函数很简单。它需要一个变量x，可能是一个int，或者是一个 float 或 double，然后输出该变量的平方。

再思考一下下面的这个函数：

global_list = []
def append_to_list(x):
    global_list.append(x)

乍一看，这个函数接受了一个变量 x，无论是哪种类型，由于没有 return 语句，它什么也不返回。事实真的是这样吗？

如果事先没有定义 global_list，那么这个函数就不能工作，它的输出是相同的列表，尽管经过了修改。虽然 global_list 没有声明输入，但当我们使用该函数时，它就会发生变化：

append_to_list(1)
append_to_list(2)
global_list

它返回了 [1,2]，而不是空列表。这可能就是问题所在，列表确实是函数的一个输入，虽然我们没有明确说明。

1.不忠于函数

这些隐含的输入，或者其他情况下的输出，有一个官方名称：副作用。虽然我们只列举了一个简单的例子，但在更复杂的程序中，这些可能会让我们面临真正的困难。

大家可以思考一下该如何测试 append_to_list：我们不仅需要阅读第一行并使用任何 x 来测试函数，还需要阅读整个定义，了解其作用，定义 global_list 并以这种方式进行测试。这个例子告诉我们，当你在处理有数千行代码的程序时，简单的东西很快就会变得乏味。

好消息是，有一个简单的解决方法：对函数作为输入的内容诚实。这样更好：

newlist = []
def append_to_list2(x, some_list):
    some_list.append(x)
append_to_list2(1,newlist)
append_to_list2(2,newlist)
newlist

我们并没有作太大的改变，输出结果仍然是 [1,2]，其他所有内容也保持不变。

但是，我们已经更改了一件事情：该代码现在没有副作用。

现在，当我们查看函数声明时，能确切知道发生了什么。如果程序运行不正常，我们也可以轻松地单独测试每个功能并查明哪个功能有问题。

2.函数式编程正在编写纯函数

具有明确声明的输入和输出的函数是没有副作用的函数，而没有副作用的函数就是纯函数。

函数编程的一个非常简单的定义是：仅用纯函数编写程序。纯函数永远不会修改变量，只会创建新的变量作为输出。

此外，对于给定输入的纯函数，我们可以得到特定的输出。相反，不纯函数可能依赖于某些全局变量。因此，如果全局变量不同，则相同的输入变量可能导致不同的输出。后者会让调试和代码维护变得更加困难。

这里有一个容易发现副作用的简单规则：由于每个函数必须具有某种输入和输出，因此没有任何输入或输出的函数声明必须是不纯的。如果采用函数式编程，这是你可能想要更改的第一个声明。

函数式编程不仅是 map 和 reduce

循环不是函数式编程中的东西。首先，我们先来思考以下的Python循环：

integers = [1,2,3,4,5,6]
odd_ints = []
squared_odds = []
total = 0
for i in integers:
    if i%2 ==1
        odd_ints.append(i)
for i in odd_ints:
    squared_odds.append(i*i)
for i in squared_odds:
    total += i

相较于我们要执行的简单操作，以上代码明显过长。而且也没有起到作用，因为我们正在修改全局变量。

相反，我们可以用以下代码替代：

from functools import reduce
integers = [1,2,3,4,5,6]
odd_ints = filter(lambda n: n % 2 == 1, integers)
squared_odds = map(lambda n: n * n, odd_ints)
total = reduce(lambda acc, n: acc + n, squared_odds)

这是完整的函数式。它比较短，也更快，因为我们不需要迭代太多的数组元素。如果你理解 filter, map 和 reduce 如何工作，代码也就不难理解了。

这并不意味着所有的函数代码都使用 map、reduce 等。这也不意味着你需要函数式编程来理解 map 和 reduce。只是当你抽象循环时，这些函数会弹出很多。

1.Lambda函数

在谈到函数式编程的历史时，许多人都是从lambda函数的发明开始的。尽管 lambda 是函数式编程毫无疑问的基石，但它们并不是根本原因。

Lambda 函数是可用于使程序起作用的工具。但是，我们也可以在面向对象的编程中使用lambda。

2.静态类型

上面的示例虽然不是静态类型的，但是它依然是函数式的。

即使静态类型为我们的代码增加了一层额外的安全保护，但是其函数正常也并非必不可少。不过，这可能是一个不错的补充。

有些编程语言的函数式编程越来越强

1.Perl

Perl 对副作用的处理方法与大多数编程语言截然不同。它包含了一个神奇的参数 $\ 。Perl 确实有它的优点，但我不会用它进行函数式编程。

2.Java

如果你在用 Java 进行函数式编程，那我只能祝你好运了。因为你的程序有一半是由静态关键字组成的，而且其他 Java 开发人员也会把你的程序视为耻辱。

这并不是说 Java 有多糟糕，而是因为它并不是为那些用函数式编程解决问题而设计的，比如数据库管理或机器学习应用程序。

3.Scala

有趣的是：Scala 的目标是统一面向对象和函数式编程。如果你觉得这有点奇怪，那你不是一个人，因为所有人都这么觉得：函数式编程的目标是完全消除副作用，而面向对象编程是把副作用保留在对象内部。

尽管如此，很多开发人员认为 Scala 是一种帮助他们从面向对象编程过渡到函数式编程的语言。或许在未来几年里，它们会更容易全面发挥作用。

4.Python

Python 鼓励函数式编程。一个事实就能看到这一点：每个函数在默认情况下至少有一个输入self。这很像Python的禅：显式比隐式好！

5.Clojure

据它的创建者说，Clojure 大约有 80% 是函数式编程。默认情况下，所有值都是不可变的，就像在函数式编程中需要它们一样。但是，我们可以通过在这些不可变的值周围使用可变值包装器来解决这个问题。当你打开这样一个包装，你得到的东西又是不变的。

6.Haskell

这是为数不多的纯函数式和静态类型的语言之一。虽然在开发过程中这看起来像是一个时间消耗器，但在调试程序时，Haskell会付出巨大的代价。它不像其他语言那么容易学，但绝对值得投资！

大数据时代带来了函数式编程

与面向对象编程相比，函数式编程仍然是一个新生儿。但是如果在 Python 和其他语言中包含函数式编程原理，具有不一样的意义，那么函数式编程就有可能获得关注。

函数式编程对于大型数据库、并行编程和机器学习非常有用。在过去的十年里，所有这些都在蓬勃发展。

虽然面向对象代码有着不可估量的优点，但函数代码的优点却不容忽视。只需要学习一些基本原理，就足以让我们成为一名开发人员，并为未来做好准备。

--END--

 IT大咖说  |  关于版权 

感谢您对IT大咖说的热心支持！