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

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

然后引入“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

这里和其他在线帖子的答案提到了以下内容:

使用声明式编程，您编写的代码描述您想要的东西，但不一定是如何得到它 您应该更喜欢声明式编程而不是命令式编程

他们没有告诉我们如何实现这一目标。为了使部分程序更具声明性，其他部分必须提供抽象来隐藏实现细节(即命令式代码)。

例如，LINQ比循环(for, while等)更具声明性，例如，你可以使用list. where()来获得一个新的过滤列表。为了实现这一点，微软已经完成了LINQ抽象背后的所有繁重工作。

事实上，函数式编程和函数式库更具有声明性的原因之一是因为它们抽象了循环和列表创建，隐藏了所有实现细节(很可能是带有循环的命令式代码)。

在任何程序中，都将同时拥有命令式代码和声明式代码，并且应该将所有命令式代码隐藏在特定于领域的抽象后面，以便程序的其他部分可以声明性地使用它们。

最后，尽管函数式编程和LINQ可以使您的程序更具声明性，但您总是可以通过提供更多的抽象来使程序更具声明性。例如:

// JavaScript example

// Least declarative
const bestProducts = [];
for(let i = 0; i < products.length; i++) {
    let product = products[i];
    if (product.rating >= 5 && product.price < 100) {
        bestProducts.push(product);
    }
}


// More declarative
const bestProducts = products.filter(function(product) {
    return product.rating >= 5 && product.price < 100;
});

// Most declarative, implementation details are hidden in a function
const bestProducts = getBestProducts();

另外，声明式编程的极端是发明新的领域特定语言(DSL):

字符串搜索:正则表达式而不是自定义命令式代码 js: JSX而不是直接的DOM操作 AWS CloudFormation:用YAML代替CLI 关系型数据库:用SQL代替旧的读写api，如ISAM或VSAM。

声明式与命令式

编程范式是计算机编程的一种基本风格。 主要有四种范式:命令式、声明式、函数式(被认为是声明式范式的子集)和面向对象的。

Declarative programming : is a programming paradigm that expresses the logic of a computation(What do) without describing its control flow(How do). Some well-known examples of declarative domain specific languages (DSLs) include CSS, regular expressions, and a subset of SQL (SELECT queries, for example) Many markup languages such as HTML, MXML, XAML, XSLT... are often declarative. The declarative programming try to blur the distinction between a program as a set of instructions and a program as an assertion about the desired answer.

命令式编程:是一种编程范式，它用改变程序状态的语句来描述计算。命令式程序可以被视为编程命令或数学断言。

函数式编程:是一种编程范式，它将计算视为数学函数的求值，并避免状态和可变数据。它强调函数的应用，而命令式编程风格强调状态的变化。 在纯函数式语言(如Haskell)中，所有函数都没有副作用，状态更改仅表示为转换状态的函数。

下面是MSDN中命令式编程的示例，循环遍历数字1到10，并找到偶数。

var numbersOneThroughTen = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//With imperative programming, we'd step through this, and decide what we want:
var evenNumbers = new List<int>();
foreach (var number in numbersOneThroughTen)
{    if (number % 2 == 0)
    {
        evenNumbers.Add(number);
    }
}
//The following code uses declarative programming to accomplish the same thing.
// Here, we're saying "Give us everything where it's even"
var evenNumbers = numbersOneThroughTen.Where(number => number % 2 == 0);

这两个例子都产生了相同的结果，一个既不比另一个好也不比另一个差。第一个示例需要更多代码，但代码是可测试的，命令式方法让您完全控制实现细节。在第二个例子中，代码可以说更可读;然而，LINQ并不能让你控制幕后发生的事情。您必须相信LINQ将提供所请求的结果。

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);
}

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

再举一个手机应用开发的例子。在iOS和Android中，我们有界面构建器，在那里我们可以定义应用程序的UI。

使用这些生成器绘制的UI本质上是声明性的，我们可以在其中拖放组件。实际的绘图发生在框架和系统下面，由框架和系统执行。

但我们也可以在代码中画出整个组件，这在本质上是必要的。

此外，一些新语言，如Angular JS，专注于以声明方式设计ui，我们可能会看到许多其他语言提供同样的支持。就像Java在Java swing或Java FX中没有任何好的声明性方法来绘制本地桌面应用程序，但在不久的将来，他们可能会这样做。

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

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