过程性语言倾向于跟踪状态(使用变量)，并倾向于按步骤序列执行。纯函数式语言不跟踪状态，使用不可变值，并倾向于作为一系列依赖项执行。在许多情况下，调用堆栈的状态所保存的信息与过程代码中存储在状态变量中的信息相同。

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

我从来没有在其他地方看到过这样的定义，但我认为这很好地总结了这里给出的差异:

函数式编程主要关注表达式

过程式编程主要关注语句

表达式有值。函数式程序是一个表达式，其值是由计算机执行的一系列指令。

语句没有值，而是修改一些概念机器的状态。

在纯函数式语言中，没有语句，也就是说没有办法操纵状态(它们可能仍然有一个名为“语句”的语法结构，但除非它操纵状态，否则我不会在这种意义上称其为语句)。在纯程序语言中，没有表达式，一切都是操纵机器状态的指令。

Haskell是纯函数式语言的一个例子，因为没有办法操纵状态。机器代码是纯过程语言的一个例子，因为程序中的所有内容都是操作机器寄存器和内存状态的语句。

令人困惑的部分是，绝大多数编程语言同时包含表达式和语句，允许您混合使用范式。语言可以根据它们鼓励使用语句和表达式的程度被分类为更函数化或更过程化。

For example, C would be more functional than COBOL because a function call is an expression, whereas calling a sub program in COBOL is a statement (that manipulates the state of shared variables and doesn't return a value). Python would be more functional than C because it allows you to express conditional logic as an expression using short circuit evaluation (test && path1 || path2 as opposed to if statements). Scheme would be more functional than Python because everything in scheme is an expression.

你仍然可以在一种鼓励过程范式的语言中以函数式风格编写，反之亦然。只是在语言不鼓励的范式下写作更困难和/或更尴尬。

这里没有一个答案显示了惯用的函数式编程。递归阶乘的答案很适合在FP中表示递归，但大多数代码不是递归的，所以我不认为这个答案是完全具有代表性的。

假设你有一个字符串数组，每个字符串表示一个整数，比如“5”或“-200”。您希望根据内部测试用例检查这个输入字符串数组(使用整数比较)。两种解决方案如下所示

程序上的

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

虽然纯函数式语言通常是研究语言(因为现实世界喜欢免费的副作用)，但现实世界的过程式语言在适当的时候会使用更简单的函数式语法。

这通常是用Lodash这样的外部库实现的，或者是用Rust这样的新语言内置的。函数式编程的繁重工作是通过map、filter、reduce、currying、partial等函数/概念完成的，最后三个你可以查阅以进一步理解。

齿顶高

In order to be used in the wild, the compiler will normally have to work out how to convert the functional version into the procedural version internally, as function call overhead is too high. Recursive cases such as the factorial shown will use tricks such as tail call to remove O(n) memory usage. The fact that there are no side effects allows functional compilers to implement the && ret optimization even when the .reduce is done last. Using Lodash in JS, obviously does not allow for any optimization, so it is a hit to performance (Which isn't usually a concern with web development). Languages like Rust will optimize internally (And have functions such as try_fold to assist && ret optimization).

要理解其中的区别，需要理解过程式编程和函数式编程的“教父”范式都是命令式编程。

基本上，过程式编程只是构造命令式程序的一种方式，其中主要的抽象方法是“过程”。(或某些编程语言中的“函数”)。甚至面向对象编程也只是构造命令式程序的另一种方式，其中状态被封装在对象中，成为一个具有“当前状态”的对象，加上这个对象有一组函数、方法和其他东西，可以让程序员操作或更新状态。

现在，关于函数式编程，其方法的要点是它确定要取什么值，以及应该如何传递这些值。(因此没有状态，也没有可变数据，因为它将函数作为第一类值，并将它们作为参数传递给其他函数)。

PS:理解所使用的每一种编程范式应该能澄清它们之间的差异。

PSS:归根结底，编程范式只是解决问题的不同方法。

PSS: quora上的这个答案有一个很好的解释。

如果你有机会，我建议你买一份Lisp/Scheme，然后用它来做一些项目。最近流行起来的大多数思想都是在几十年前用Lisp表达的:函数式编程、延续(作为闭包)、垃圾收集，甚至XML。

所以这将是一个很好的方法来开始所有这些当前的想法，以及一些其他的，比如符号计算。

您应该知道函数式编程擅长什么，不擅长什么。它并不是什么都好。有些问题最好用副作用来表达，同样的问题会根据提问的时间给出不同的答案。

函数式语言(理想情况下)允许您编写一个数学函数，即接受n个参数并返回一个值的函数。如果程序被执行，这个函数将根据需要在逻辑上求值

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

因此，纯函数式程序总是对输入产生相同的值，求值的顺序没有很好的定义;这意味着像用户输入或随机值这样的不确定值很难用纯函数式语言建模。

就像这个答案中的其他内容一样，这是一种概括。这个属性，在需要计算结果的时候计算，而不是在调用它的时候按顺序计算，被称为“懒惰”。并不是所有的函数式语言都是懒惰的，懒惰也不仅仅局限于函数式编程。相反，这里给出的描述提供了一个“心理框架”，用于思考不同的编程风格，这些风格不是不同的、相反的类别，而是流动的想法。