编程的世界：为什么需要函数式思维

编程的世界：为什么需要函数式思维

从一道菜谱看编程的本质

Imagine this scenario: it's Saturday afternoon, and you're in the kitchen with a cookbook open in front of you. The recipe for "Scrambled Eggs with Tomatoes" reads something like this:

1. Crack 3 eggs into a bowl 2. Add a pinch of salt and whisk until uniform 3. Heat the pan over medium flame 4. Pour in the egg mixture 5. Stir continuously until the eggs are 70% cooked 6. Add diced tomatoes 7. Continue stirring for another minute 8. Turn off the heat and serve

This is a perfect example of imperative programming in daily life. The recipe tells you step by step what to do: first do this, then do that, and finally finish. Each step is an instruction telling your body exactly how to move, and you must execute them in strict order.

Now imagine another scenario: you hand this task to a professional chef and simply say, "Scrambled eggs with tomatoes, medium saltiness." The chef, without needing your detailed instructions, already understands what needs to be done and can complete it. This is closer to declarative programming—you describe the desired result, not the specific steps to achieve it.

Programming, at its core, is giving instructions to computers. Whether it's making a cup of coffee, processing data, or building a complex system, we are essentially translating our intentions into a language the computer can understand. The difference lies in how we express these intentions. Some approaches tell the computer step by step what to do, while others describe what we want to achieve and let the computer figure out the execution path.

两种思维: Imperative vs. Declarative

The distinction between imperative and declarative programming is one of the most fundamental differences in programming paradigms. Understanding this distinction is crucial for appreciating why functional programming, which represents the declarative approach, has gained increasing importance in modern software development.

命令式编程：一步一步指挥计算机

Imperative programming is like a detailed instruction manual. It tells the computer exactly what to do, step by step, in a specific order. The program is a sequence of commands that modify the program's state. Variables are containers that store values, and these values change as the program executes.

Consider a simple example: calculating the sum of numbers from 1 to 100. In an imperative style, typically using Python, the code might look like this:

```python total = 0 i = 1 while i <= 100: total = total + i i = i + 1 print(total) ```

This code explicitly tells the computer: "First, set `total` to 0. Then, set `i` to 1. Next, enter a loop, add `i` to `total`, increment `i` by 1 each time, and continue until `i` exceeds 100. Finally, output `total`."

The characteristics of imperative programming are clearly evident in this example:

• **State changes over time**: Variables `total` and `i` change their values as the program runs.
• **Sequential execution**: Commands are executed in a predetermined order.
• **Explicit flow control**: Loop structures (`while`, `for`) explicitly control the program's flow.
• **Mutable data**: The value of `total` is modified with each iteration.

This way of thinking is very intuitive because it mirrors how we describe tasks in everyday life. "First do A, then do B, and if condition C is met, do D." This linear, step-by-step thinking pattern has dominated programming for decades and remains the primary approach in many popular languages today.

声明式编程：描述你想要的结果

Declarative programming, on the other hand, takes a fundamentally different approach. Instead of telling the computer how to do something, you tell it what you want. The computer then determines the best way to achieve that goal. This paradigm emphasizes the description of logic rather than the control flow.

Going back to the sum of 1 to 100 example, in a declarative style using Python, you might write:

```python total = sum(range(1, 101)) print(total) ```

Or in Haskell:

```haskell main :: IO () main = print $ sum [1..100] ```

These examples describe what we want—the sum of numbers from 1 to 100—without explicitly detailing the steps to compute it. The computer knows how to compute sums and generate sequences, so we don't need to specify the loop mechanism ourselves.

Declarative programming manifests in many forms in modern software development:

• **SQL queries**: `"SELECT name, age FROM users WHERE age > 18"` describes the data you want, not how to scan through the database.
• **HTML/CSS**: HTML describes the structure of a document; CSS describes the visual style, without specifying how the browser should render them step by step.
• **Regular expressions**: They describe the pattern of text you want to match, not the character-by-character comparison process.

The beauty of declarative programming lies in its ability to hide implementation details and allow programmers to focus on higher-level goals. When you write a SQL query, you don't need to think about which index to use, how to traverse the B-tree, or how to manage memory buffers. The database engine handles these details intelligently.

三种语言, 三种范式

To better illustrate the differences between programming paradigms, let's examine how three representative programming languages approach the same problem: processing a list of numbers to find those greater than 10, then calculate their squares, and finally sum them.

Python: The Imperative Workhorse

Python, one of the most popular programming languages today, supports multiple programming styles but defaults to imperative programming. Here's how you might solve our problem imperatively in Python:

```python numbers = [3, 12, 7, 19, 5, 28, 42, 1, 9, 15]

Step 1: Initialize result variable

total = 0

Step 2: Iterate through the list

for n in numbers:

Step 3: Check condition

if n > 10:

Step 4: Calculate square and add to total

total = total + n * n

Step 5: Output result

print(total) ```

This code follows a clear step-by-step pattern. It reads like an instruction manual: first set `total` to 0, then iterate through the list, check each number, if it's greater than 10, calculate its square and add it to `total`, finally print the result.

However, notice how we explicitly manage the state (`total`) and flow control (`for`, `if`). This approach works well for small programs but can become harder to manage as the logic grows more complex. What if we need to add logging, error handling, or parallelization? Each addition would require carefully modifying the state management logic.

Python also supports a more declarative style through list comprehensions:

```python numbers = [3, 12, 7, 19, 5, 28, 42, 1, 9, 15] result = sum(n * n for n in numbers if n > 10) print(result) ```

This version is more concise and declarative—we describe what we want rather than how to achieve it. Notice how the variables `result` and `n` are still mutable in the underlying implementation, but the syntax allows us to express the logic more clearly.

JavaScript: The Multi-Paradigm Language

JavaScript, the language of the web, was originally designed as a simple scripting language but has evolved into a full-featured multi-paradigm language. It supports imperative, object-oriented, and functional programming styles. Let's see how JavaScript handles our problem in different ways.

First, the imperative approach using a traditional loop:

```javascript const numbers = [3, 12, 7, 19, 5, 28, 42, 1, 9, 15];

let total = 0; for (let i = 0; i < numbers.length; i++) { if (numbers[i] > 10) { total += numbers[i] * numbers[i]; } } console.log(total); ```

This code is similar to Python's imperative version, with explicit loop control using an index variable `i`. Now, let's look at a more functional approach using JavaScript's array methods:

```javascript const numbers = [3, 12, 7, 19, 5, 28, 42, 1, 9, 15];

const result = numbers .filter(n => n > 10)