返回专栏
· 14 分钟阅读

声明式编程与命令式编程


一、什么是命令式编程与声明式编程?

命令式编程(Imperative Programming)和声明式编程(Declarative Programming)是两种不同的程序表达方式。

  • 命令式编程:告诉计算机应该执行哪些操作,以及按照什么顺序完成任务。
  • 声明式编程:告诉计算机希望得到什么结果,而不必详细描述具体执行步骤。

两者最核心的区别是:

  • 命令式编程关注 How:如何实现。
  • 声明式编程关注 What:希望实现什么。

例如,现在需要从一组数字中筛选出所有大于 10 的数字。

命令式写法:

numbers = [3, 12, 5, 18, 9, 20]
result = []

for number in numbers:
    if number > 10:
        result.append(number)

print(result)

开发者明确描述了:

  1. 创建一个结果列表。
  2. 遍历原始列表。
  3. 判断当前数字是否大于 10。
  4. 满足条件时添加到结果列表。
  5. 输出最终结果。

声明式写法:

numbers = [3, 12, 5, 18, 9, 20]

result = list(filter(lambda x: x > 10, numbers))

print(result)

这里主要表达筛选条件,不需要手动描述结果列表如何创建、元素如何逐个添加。

两种写法实现了相同的目标,但抽象层次不同。

需要注意,命令式与声明式并不是两种互斥的编程语言分类,而是两种编程思想。很多现代语言同时支持这两种风格。

二、命令式编程的工作原理

1. 命令式编程是什么?

命令式编程通过一系列明确的指令,描述程序应该如何完成任务。

它通常直接操作程序状态,通过变量赋值、条件判断、循环和函数调用控制程序执行。

例如:

balance = 1000

balance = balance - 200
balance = balance + 500

print(balance)

程序明确规定:

  • 初始余额为 1000。
  • 扣除 200。
  • 增加 500。
  • 输出最终余额。

程序执行过程中,变量 balance 的状态不断发生变化。

2. 命令式编程的基本组成

变量与状态

通过变量保存程序运行过程中的数据。

count = 0
count = count + 1

顺序执行

按照代码编写的顺序执行操作。

a = 10
b = 20
c = a + b

条件判断

根据条件决定执行不同的代码分支。

if age >= 18:
    print("成年人")
else:
    print("未成年人")

循环控制

通过循环重复执行某些操作。

for i in range(5):
    print(i)

状态修改

通过赋值和操作改变程序中的数据。

user = {
    "name": "Tom",
    "age": 18
}

user["age"] = 19

这些机制共同构成了命令式程序的执行逻辑。

3. 命令式程序的执行流程

flowchart TB
    A["程序开始"] --> B["初始化变量"]
    B --> C["执行第一条指令"]
    C --> D["读取当前状态"]
    D --> E["执行操作并修改状态"]
    E --> F{"是否还有后续指令"}
    F -->|"是"| D
    F -->|"否"| G["输出结果"]
    G --> H["程序结束"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

4. 命令式编程的主要特点

  • 执行步骤明确:开发者需要描述具体操作。
  • 状态变化直观:变量、对象和数据结构可以被直接修改。
  • 控制能力强:可以精细控制循环、分支、内存和执行顺序。
  • 抽象层次相对较低:部分实现细节需要开发者自行处理。
  • 执行过程容易追踪:可以按照指令顺序分析程序状态变化。

5. 常见命令式编程语言

语言 典型应用
C 操作系统、嵌入式开发
C++ 游戏引擎、基础设施
Java 企业级应用、后端服务
Go 网络服务、云原生系统
Python 自动化、数据处理、后端开发
JavaScript Web 前端、后端开发

这些语言也支持声明式编程风格,只是命令式表达在其中非常常见。

三、声明式编程的工作原理

1. 声明式编程是什么?

声明式编程通过描述目标、规则、约束或期望状态,让底层系统决定如何完成任务。

开发者通常不需要详细指定每一步执行操作。

例如 SQL:

SELECT name, age
FROM users
WHERE age > 18
ORDER BY age DESC;

这段 SQL 表达了:

  • 从 users 表中查询数据。
  • 筛选年龄大于 18 的记录。
  • 返回姓名和年龄。
  • 按年龄降序排列。

开发者没有明确规定:

  • 如何遍历数据。
  • 如何判断每一条记录。
  • 使用什么排序算法。
  • 是否使用索引。
  • 是否采用并行执行。

这些工作由数据库管理系统根据查询计划和运行环境决定。

2. 声明式编程的基本组成

目标描述

描述最终希望得到什么结果。

例如:

SELECT * FROM users;

表达查询所有用户,而不是描述逐条读取记录的操作。

规则与约束

描述系统必须满足的条件。

例如 CSS:

.container {
    display: flex;
    justify-content: center;
    align-items: center;
}

开发者声明布局规则,浏览器布局引擎负责计算元素的位置。

状态描述

描述系统应该达到的状态。

例如 Kubernetes 配置:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
        - name: web
          image: nginx:latest

这段配置声明希望运行三个副本的应用。

开发者不需要手动编写每个容器的创建、监控和故障恢复步骤。Kubernetes 控制器负责持续协调实际状态与期望状态。

3. 声明式程序的执行流程

flowchart TB
    A["描述目标或期望状态"] --> B["系统解析声明"]
    B --> C["生成执行计划"]
    C --> D["底层执行引擎"]
    D --> E["执行具体操作"]
    E --> F["获得执行结果"]
    F --> G["检查是否满足目标"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,不同声明式系统的执行方式并不相同。

SQL 通常由数据库优化器生成查询执行计划;CSS 由浏览器布局和渲染引擎处理;Kubernetes 则通过控制器持续协调实际状态与期望状态。

4. 声明式编程的主要特点

  • 关注最终目标:重点表达希望得到什么结果。
  • 隐藏执行细节:底层系统负责具体操作。
  • 抽象层次较高:开发者可以减少重复的底层实现代码。
  • 表达能力集中:通过规则、约束或查询描述业务意图。
  • 依赖执行引擎:实际执行效率和行为受到底层系统实现影响。

5. 常见声明式技术

技术 声明内容 执行主体
SQL 数据查询和筛选条件 数据库引擎
HTML 文档结构 浏览器
CSS 页面样式和布局规则 浏览器渲染引擎
React JSX UI 结构和组件关系 React 运行时
Kubernetes YAML 集群期望状态 Kubernetes 控制器
Terraform HCL 基础设施期望配置 Terraform 引擎
正则表达式 字符串匹配规则 正则表达式引擎

四、命令式与声明式的核心区别

对比维度 命令式编程 声明式编程
核心关注 如何完成任务 希望得到什么结果
表达方式 操作指令 目标、规则、约束
控制权 更多掌握在开发者手中 更多交给底层执行系统
状态管理 经常显式修改状态 通常描述目标或数据关系
抽象层次 相对较低 通常较高
实现细节 需要描述较多 通常由执行引擎处理
灵活性 可以精细控制执行过程 受声明模型和执行引擎约束
典型技术 循环、赋值、条件判断 SQL、CSS、HTML、YAML

1. 同一个任务的两种实现

假设需要计算一组商品的总价格。

命令式实现:

prices = [100, 200, 300]

total = 0

for price in prices:
    total += price

print(total)

开发者描述了:

  • 初始化总金额。
  • 遍历价格列表。
  • 将当前价格累加到总金额。
  • 输出最终结果。

声明式风格:

prices = [100, 200, 300]

total = sum(prices)

print(total)

这里直接使用 sum() 表达求和意图。

底层函数负责完成遍历和累加。

需要注意,调用 sum() 并不意味着 Python 程序变成了纯声明式程序。它只是通过更高层次的抽象表达了计算目标。

2. 两种编程思想的抽象层次

flowchart TB
    A["业务目标"] --> B["声明式描述"]
    A --> C["命令式描述"]
    B --> D["声明目标、规则和约束"]
    D --> E["执行引擎决定实现方式"]
    C --> F["描述具体执行步骤"]
    F --> G["开发者控制操作过程"]
    E --> H["获得结果"]
    G --> H

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

两种方式解决的是同一个问题,只是开发者与底层执行系统之间的职责分配不同。

五、声明式编程的典型应用

声明式编程并不是一种只存在于理论中的思想,在现代软件开发中非常常见。

1. SQL:声明查询目标

SQL 是最典型的声明式语言之一。

例如:

SELECT *
FROM orders
WHERE amount > 1000
ORDER BY created_at DESC;

这条语句表达查询需求:

  • 查询订单。
  • 筛选金额大于 1000 的记录。
  • 按创建时间降序排列。

数据库管理系统会根据表结构、索引、统计信息和执行环境生成查询计划。

例如,数据库可能选择:

  • 全表扫描。
  • 索引扫描。
  • 索引范围扫描。
  • 排序操作。
  • 并行执行。

开发者通常不需要手动指定这些细节。

SQL 背后的执行机制

flowchart TB
    A["SQL 查询语句"] --> B["词法与语法分析"]
    B --> C["语义检查"]
    C --> D["查询优化器"]
    D --> E["生成执行计划"]
    E --> F["数据库执行引擎"]
    F --> G["返回查询结果"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里有一个重要概念:声明式并不意味着系统不需要执行步骤,而是执行步骤由底层系统决定。

数据库仍然需要遍历数据、计算条件和执行排序,只是这些操作不需要由 SQL 使用者逐条编写。

2. HTML 与 CSS:声明页面结构和样式

HTML 用于描述页面结构。

<div class="card">
    <h2>用户信息</h2>
    <p>欢迎使用系统</p>
</div>

CSS 用于描述页面样式:

.card {
    width: 300px;
    padding: 20px;
    background: #ffffff;
    border-radius: 12px;
}

开发者声明元素结构和样式规则。

浏览器负责:

  • 解析 HTML。
  • 构建 DOM。
  • 解析 CSS。
  • 计算样式。
  • 计算布局。
  • 绘制页面。
  • 合成最终画面。

3. React:声明式 UI

React 是现代前端开发中声明式编程思想的重要代表。

传统命令式 DOM 操作:

const button = document.createElement("button");

button.textContent = "点击次数:0";

document.body.appendChild(button);

let count = 0;

button.addEventListener("click", () => {
    count++;
    button.textContent = `点击次数:${count}`;
});

开发者需要明确:

  • 创建 DOM 元素。
  • 设置文本。
  • 插入页面。
  • 监听点击事件。
  • 修改变量。
  • 更新 DOM 内容。

React 声明式写法:

import { useState } from "react";

function Counter() {
    const [count, setCount] = useState(0);

    return (
        <button onClick={() => setCount(count + 1)}>
            点击次数:{count}
        </button>
    );
}

开发者描述:

  • 当前状态是什么。
  • 页面应该如何根据状态显示。
  • 用户操作如何更新状态。

React 负责根据状态变化协调 UI 更新。

这里的核心思想是:

UI 是状态的描述,状态变化后,界面按照新的状态重新协调。

需要注意,React 并不是完全没有命令式操作。开发者仍然可以通过 useRef、DOM API 和副作用处理等方式执行命令式操作。

4. Kubernetes:声明期望状态

Kubernetes 是声明式基础设施管理的重要案例。

例如:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest

这段配置声明:

  • 需要一个 Deployment。
  • 应用名称为 nginx-app。
  • 期望运行三个副本。
  • 使用指定的容器镜像。

Kubernetes 控制器会持续比较实际状态和期望状态。

如果某个 Pod 异常退出,控制器会尝试重新创建 Pod,使系统回到期望状态。

Kubernetes 的声明式控制机制