Functional programming 过程式编程和函数式编程的区别是什么？

我已经阅读了和的维基百科文章，但我仍然有点困惑。有人能把它归结为核心吗？

在计算机科学中，函数编程是一种编程范式，它将计算视为对数学函数的评估，并避免状态和可变数据。它强调函数的应用，与强调状态变化的过程编程风格相反。

函数语言（理想情况下）允许您编写数学函数，即接受n个参数并返回值的函数。如果执行该程序，则根据需要对该函数进行逻辑计算。1

另一方面，过程语言执行一系列连续的步骤。（有一种将顺序逻辑转换为函数逻辑的方法，称为。）

因此，一个纯功能程序总是为一个输入产生相同的值，并且计算顺序没有很好的定义；这意味着像用户输入或随机值这样的不确定值很难用纯函数式语言建模

---

---

1和这个答案中的其他内容一样，这是一个概括。这种属性，在需要计算结果时对其进行评估，而不是在调用时按顺序进行评估，称为“惰性”。并非所有函数式语言实际上都是懒惰的，懒惰也不局限于函数式编程。相反，这里给出的描述提供了一个“思维框架”，用来思考不同的编程风格，这些风格不是截然不同的、对立的类别，而是流动的想法。

要扩展Konrad的评论：

因此，一个纯功能程序总是为一个输入产生相同的值，并且计算顺序没有很好的定义

因此，函数代码通常更容易并行化。由于函数（通常）没有副作用，并且它们（通常）只根据参数进行操作，所以很多并发问题都消失了

当您需要能够证明代码正确时，也可以使用函数式编程。这对于过程编程来说要困难得多（函数编程不容易，但更容易）

---

免责声明：我已经多年没有使用函数式编程了，只是最近才开始重新研究它，所以我在这里可能不完全正确。：）

我相信程序/功能/目标编程是关于如何处理问题的

第一种方式是将所有事情规划成步骤，并通过一次执行一个步骤（一个过程）来解决问题。另一方面，函数式编程将强调分而治之的方法，即将问题划分为子问题，然后解决每个子问题（创建函数来解决该子问题），并将结果组合起来为整个问题创建答案。最后，目标编程通过在计算机内部创建一个包含许多对象的小世界来模拟现实世界，每个对象都有（某种程度上）独特的特征，并与其他对象交互。从这些相互作用中，结果就会显现出来

每种编程风格都有自己的优缺点。因此，做一些诸如“纯编程”之类的事情（即纯过程性的——顺便说一句，没有人这样做，这有点奇怪——或者纯功能性的或纯目标性的）是非常困难的，如果不是不可能的话，除了一些专门设计用来展示编程风格优势的基本问题（因此，我们称那些喜欢纯净的人为“小鬼”：D）

---

然后，从这些风格中，我们有针对每种风格进行优化的编程语言。例如，汇编语言都是程序化的。好吧，大多数早期语言都是程序化的，不仅仅是Asm，比如C、Pascal（我听说还有Fortran）。然后，我们都有目标学派中著名的Java（事实上，Java和C#也在一个名为“面向金钱”的课程中，但这是另一个讨论的主题）。同样的目标是Smalltalk。在功能学校，我们会有“几乎功能化”（有些人认为它们是不纯的）Lisp家族和ML家族，还有许多“纯粹功能化的”Haskell、Erlang等。顺便说一句，有许多通用语言，如Perl、Python、Ruby。

来扩展Konrad的评论：

评价的顺序也不尽相同 明确的

有些函数式语言有所谓的延迟求值。这意味着函数只有在需要值时才会执行。在这之前，函数本身就是传递的对象

---

过程语言是第1步第2步第3步…如果在第2步中你说添加2+2，那么它就正确了。在惰性计算中，你会说添加2+2，但如果结果从未使用过，它就永远不会进行添加。

过程语言倾向于跟踪状态（使用变量）并倾向于作为一系列步骤执行。纯函数语言不跟踪状态，使用不可变值，倾向于作为一系列依赖项执行。在许多情况下，调用堆栈的状态将包含与过程代码中状态变量中存储的信息等效的信息

---

递归是函数式编程的一个经典例子。

基本上这两种编程风格类似于阴阳。一种是有组织的，而另一种是混乱的。有些情况下，函数式编程是明显的选择，而其他情况下，过程式编程是更好的选择。这就是为什么至少有两种语言ges最近推出了一个新版本，它包含了两种编程风格

#程序性：#

• 例程的输出并不总是与输入直接相关
• 一切都是按特定的顺序进行的
• 执行例行程序可能有副作用
• 倾向于强调实施解决方案

  fac n = foldr (*) 1 [1..n]
  

  prouduct list = foldr 1 (*) list
  

  product = foldr 1 (*)
  

  fac n = foldr 1 (*)  [1..n]
  

  fac n = product [1..n]
  

  arr_equal(a : [Int], b : [Str]) -> Bool {
      if(a.len != b.len) {
          return false;
      }
  
      bool ret = true;
      for( int i = 0; i < a.len /* Optimized with && ret*/; i++ ) {
          int a_int = a[i];
          int b_int = parseInt(b[i]);
          ret &= a_int == b_int;  
      }
      return ret;
  }
  

  eq = i, j => i == j # This is usually a built-in
  toInt = i => parseInt(i) # Of course, parseInt === toInt here, but this is for visualization
  
  arr_equal(a : [Int], b : [Str]) -> Bool =
      zip(a, b.map(toInt)) # Combines into [Int, Int]
     .map(eq)
     .reduce(true, (i, j) => i && j) # Start with true, and continuously && it with each value