函数式、并发式、过程式、面向对象风格的编程范式

编程范式（Programming Paradigm）是编程的“风格”或“方法论”，它定义了程序员如何组织代码、管理数据和控制流程。以下是 函数式、并发式、过程式和面向对象 四种常见编程范式的核心概念和示例：

1. 函数式编程（Functional Programming, FP）

核心思想

• 函数是一等公民：函数可以像变量一样传递、返回或存储。
• 避免副作用：函数不修改外部状态，仅依赖输入参数并返回输出。
• 不可变数据：数据一旦创建就不能修改，避免意外变更。
• 高阶函数：函数可以接受其他函数作为参数，或返回函数。

示例（Python）

# 高阶函数：map 遍历列表并应用函数
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x ** 2, numbers))  # [1, 4, 9, 16]

# 纯函数：无副作用，输入相同则输出相同
def add(a, b):
    return a + b  # 不修改外部变量

# 递归代替循环（避免可变状态）
def factorial(n):
    return 1 if n == 0 else n * factorial(n - 1)

适用场景

• 数据处理（如 MapReduce、大数据分析）。
• 并行计算（无副作用的函数易并行化）。
• 函数组合（如前端 React 的 useState 钩子）。

2. 并发式编程（Concurrent Programming）

核心思想

• 同时执行多个任务：通过多线程、多进程或异步 I/O 实现。
• 共享资源管理：避免竞态条件（Race Condition）和数据竞争。
• 同步机制：使用锁、信号量、通道（Channel）等协调任务。

示例（Python 多线程）

import threading

# 共享资源
counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:  # 加锁避免竞态条件
        counter += 1

threads = []
for _ in range(100):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(counter)  # 输出 100（无锁时可能小于 100）

其他并发模型

• 异步编程（Async/Await）：如 JavaScript 的 Promise 或 Python 的 asyncio。
• Actor 模型：如 Erlang/Elixir 的进程间通信。
• CSP（Communicating Sequential Processes）：如 Go 的 goroutine 和 channel。

适用场景

• 高并发服务器（如 Web 后端、聊天应用）。
• I/O 密集型任务（如爬虫、文件处理）。
• 实时系统（如游戏、金融交易）。

3. 过程式编程（Procedural Programming）

核心思想

• 步骤化：将程序分解为一系列过程（函数）和语句。
• 顺序执行：代码从上到下执行，通过函数调用组织逻辑。
• 全局数据：变量可以全局访问（需谨慎管理）。

示例（C 语言）

#include <stdio.h>

// 全局变量
int global_var = 10;

// 过程（函数）
void print_sum(int a, int b) {
    int result = a + b + global_var;
    printf("Sum: %d\n", result);
}

int main() {
    int x = 5, y = 3;
    print_sum(x, y);  // 调用过程
    return 0;
}

特点

• 自顶向下设计：先写主流程，再拆分函数。
• 易理解：适合小型程序或脚本。
• 缺点：数据与逻辑分离，大型项目易混乱。

适用场景

• 简单脚本（如 Bash、Python 脚本）。
• 嵌入式系统（资源受限时）。
• 教学（初学者易上手）。

4. 面向对象编程（Object-Oriented Programming, OOP）

核心思想

• 对象：数据（属性）和操作（方法）的封装体。
• 类：对象的模板，定义属性和方法。
• 四大特性：
  • 封装：隐藏内部细节，暴露接口。
  • 继承：子类复用父类代码。
  • 多态：同一方法在不同类中有不同实现。
  • 抽象：提取关键特征，忽略非本质细节。

示例（Python）

# 类定义
class Animal:
    def __init__(self, name):
        self.name = name  # 属性

    def speak(self):  # 方法
        raise NotImplementedError("子类必须实现此方法")

# 继承
class Dog(Animal):
    def speak(self):
        return f"{self.name} 说：汪汪！"

class Cat(Animal):
    def speak(self):
        return f"{self.name} 说：喵喵！"

# 多态
animals = [Dog("阿黄"), Cat("小花")]
for animal in animals:
    print(animal.speak())
# 输出：
# 阿黄 说：汪汪！
# 小花 说：喵喵！

适用场景

• 大型软件（如 GUI 应用、游戏引擎）。
• 需要建模现实世界的系统（如银行账户、电商订单）。
• 代码复用（通过继承和多态）。

总结对比

混合使用

现代语言通常支持多种范式（如 Python 支持函数式、过程式和 OOP）：

# Python 混合范式示例
from functools import reduce

# 函数式
numbers = [1, 2, 3]
sum_func = reduce(lambda x, y: x + y, numbers)  # 6

# 面向对象
class Calculator:
    def add(self, a, b):
        return a + b

calc = Calculator()
sum_oop = calc.add(1, 2)  # 3

选择范式时，需根据 问题域（如数据处理用函数式，GUI 用 OOP）和 团队习惯 决定。