命令式编程——你编写完成工作的代码

声明式编程——由其他人编写完成工作的代码

这种差异主要与抽象的总体水平有关。对于声明式，在某些情况下，您离单个步骤太远了，以至于程序在如何获得结果方面有很大的自由度。

你可以把每一条指令都看作是连续体上的某个地方:

抽象程度:

Declarative <<=====|==================>> Imperative

声明性真实世界的例子:

图书管理员，请帮我借一本《白鲸记》。 (图书管理员可酌情选择最佳的申请方式)

现实世界的例子:

进入图书馆 查找图书组织系统(卡片目录-老派) 研究如何使用卡片目录(你也忘了，对吧) 弄清楚货架是如何标记和组织的。 弄清楚书架上的书是如何排列的。 从卡片目录和组织系统中交叉引用图书位置以查找所述书籍。 带书到退房系统。 借书。

From my understanding, both terms have roots in philosophy, there are declarative and imperative kinds of knowledge. Declarative knowledge are assertions of truth, statements of fact like math axioms. It tells you something. Imperative, or procedural knowledge, tells you step by step how to arrive at something. That's what the definition of an algorithm essentially is. If you would, compare a computer programming language with the English language. Declarative sentences state something. A boring example, but here's a declarative way of displaying whether two numbers are equal to each other, in Java:

public static void main(String[] args)
{
    System.out.print("4 = 4.");
}

另一方面，英语中的祈使句给出命令或提出某种请求。因此，命令式编程只是一个命令列表(做这个，做那个)。下面是在Java中，在接受用户输入时显示两个数字是否相等的强制方法:

private static Scanner input;    

public static void main(String[] args) 
{
    input = new Scanner(System.in);
    System.out.println();
    System.out.print("Enter an integer value for x: ");
    int x = input.nextInt();
    System.out.print("Enter an integer value for y: ");        
    int y = input.nextInt();

    System.out.println();
    System.out.printf("%d == %d? %s\n", x, y, x == y);
}

从本质上讲，声明性知识跳过某些元素，在这些元素之上形成一个抽象层。声明式编程也是如此。

声明性编程是你说你想要什么，命令式编程是你说如何得到你想要的。

一个简单的Python例子:

# Declarative
small_nums = [x for x in range(20) if x < 5]

# Imperative
small_nums = []
for i in range(20):
    if i < 5:
        small_nums.append(i)

第一个例子是声明性的，因为我们没有指定构建列表的任何“实现细节”。

以c#为例，一般来说，使用LINQ的结果是声明式的，因为你没有说如何获得你想要的东西;你只是在说你想说的话。你可以对SQL说同样的话。

声明式编程的一个好处是，它允许编译器做出可能比手工编写更好的代码的决定。运行SQL示例，如果您有这样的查询

SELECT score FROM games WHERE id < 100;

SQL“编译器”可以“优化”这个查询，因为它知道id是一个索引字段——或者它可能没有索引，在这种情况下，它必须遍历整个数据集。或者SQL引擎知道这是利用所有8个核心进行快速并行搜索的最佳时机。作为程序员，你不需要考虑这些条件，也不需要编写代码来处理任何特殊情况。

我发现基于幂等性和交换性更容易区分陈述性和命令性。通过参考资料来了解他们。

看看这个简化版，了解幂等性。

然后引入“WHAT”和“HOW”的定义，以理解“WHAT”和“HOW”的实际含义。在声明式中，通过定义数据之间的关系来连接数据。你没有提到这种关系应该如何实现，而是“这种关系是什么”。通过关系来描述输出数据的“样子”，而不是“如何”来实现输出数据。

开始在脑海中画一些图表，画一些点(数据)，用线(关系)连接起来。画所有可能的方式，一比多，多比一&一比一。为这些行添加箭头，如<-----------。所有箭头都应该朝左，因为必须先计算特定数据所基于的所有数据，然后再向左移动以计算该特定数据。

如果数据a基于数据b，那么数据c和数据d又可能基于其他一些数据。然后先计算b c d，然后才计算a。所以a在这条线的左边其他的都在右边。从b c d有3条线到达a。

这个图表有一些属性:

NO data will violate the relationship it has with all other data control flow or the order doesn't matter, of course b, c and d should be calculated before a but there is no preference between b, c and d i.e. it doesn't matter which one of these 3 is calculated first (commutative) a is only based upon b, c and d and no one else. Hence, it doesn't matter how many times the relationship operation that calculates a using b, c and d is executed, same a should be achieved (idempotent). a is the end result of the relationship operation here. Basically, everyone who is affecting a should have a line pointing to a.

这些关系(线)就像函数(数学函数而不是编程函数)。毫无疑问，函数式编程在学术界很有名。纯函数(在我们的编程中，因此不是粗体)就像函数(在数学中，因此是粗体)。

到目前为止，声明性可能听起来像PURE和IMMUTABLE(通常用于函数式编程)，如果是GOOD，如果不是GREAT。因为这不是这里的目的，这是从这个模式中自动出现的。

如果你的一段代码可以转换成这个图表，那么它就是完全声明性的，否则，它就在尺度上的其他地方。

说明性很接近数学。

现在让我们放大这些关系(行)，看看在程序执行期间计算机内部发生了什么。

命令式进来了。这就是底层工作完成的地方。在命令式中，你会一步一步地提到“如何”完成它，你知道这一系列步骤将在一个数据(输入b c d)和另一个数据(输出a)之间创建所请求的关系。在这里，你创建变量，改变它们，循环数组和所有其他事情。

命令式接近编程。

我不认为程序是声明式的或命令式的，我更喜欢把它放在最左边是完全声明式的，最右边是完全命令式的。记住，声明式是建立在命令式之上的，因此你看到的任何声明式的东西实际上都是命令式的。一般来说，程序是声明式和命令式的混合。

现在，让我们举两个例子:

第二个例子可以转换成这样的图表:

reduce_r map_r filter_r A <--------- b <--------- c <--------- d

Filter_r(关系):c只是d的偶数 Map_r(关系):b是所有数字乘以10的c Reduce_r (relationship): a是b加起来的所有数字

这应该看起来像数学的复合函数:reduce_r(map_r(filter_r(d)))

在声明中，开发人员的工作是将最终目标(a)分解为有助于实现最终目标的子目标(b, c)。

当然后台程序的映射、缩减和过滤是运行的必要代码。

值得思考的是:如果您需要对map函数做一个假设，从左到右，以使您的代码按预期工作，那么您实际上是在以声明的名义执行命令式操作。

参考资料:purpleidea (James)， www.dataops.live, wiki.c2.com

Imperative programming requires developers to define step by step how code should be executed. To give directions in an imperative fashion, you say, “Go to 1st Street, turn left onto Main, drive two blocks, turn right onto Maple, and stop at the third house on the left.” The declarative version might sound something like this: “Drive to Sue’s house.” One says how to do something; the other says what needs to be done. The declarative style has two advantages over the imperative style: It does not force the traveler to memorize a long set of instructions. It allows the traveler to optimize the route when possible.

卡尔弗特，C库尔卡尼，D(2009)。LINQ至关重要。艾迪森·韦斯利48岁